You are on page 1of 88

Taller de Linux

Iniciación al Sistema Operativo LINUX
Actividades para la distribución microLINUX _VEM_1.0

Autor: Vicente Escudero Martínez

(En blanco)

2

Índice Recomendación: Quien participe en este taller de LINUX debe realizar las actividades según el orden propuesto. Esto ayudará a asimilar sin dificultad los aspectos de índole teórica y práctica tratados. -----------------------------------------------------------------------------Actividad 0: Presentación de microLINUX. Características más relevantes. Página 5. Acceso al sistema, ayuda en línea, cambio de sesión y cierre. Página 7. La consola. Intérprete de comandos (shell), comandos internos (built-in), comandos externos y aplicaciones. Página 11. Directorios de microLINUX. Creación, posición del usuario, cambio de ubicación, consulta de contenido y borrado de directorios. Página 13. Tratamiento de ficheros I. Tipos (código de colores), creación, consulta, copia y borrado de ficheros. Expansión de nombres de ficheros. Página 17. Proceso de arranque. Ficheros de configuración e inicio en microLINUX. Página 19. Tratamiento de ficheros II. Edición de ficheros de texto con editor vi. Página 21. Tratamiento de ficheros III. Enlaces fuerte y débil. Página 23. Tratamiento de ficheros IV. Búsqueda, ordenación y extracción selectiva de datos. Página 25. Gestión de usuarios. Creaci ón, propiedades y borrado de usuarios. Cambio de usuario. Página 29. Concepto de grupo. Creación y borrado de grupos. Agregación y eliminación de usuarios a un grupo. Página 33. Permisos en un sistema multiusuario. Página 37. Procesos en LINUX. Estado de un proceso. Ejecución en primer y segundo plano. Página 41. Scripts I. Ficheros de usuario ejecutados por el intérprete de comandos. Variables de entorno. Página 45. Scripts II. Ampliación de comandos y Funciones. Página . Scripts III. Estructuras de control. Página 53. Información del kernel I. Datos suministrados durante el inicio del sistema. Página 61. Información del kernel II. Datos del sistema en tiempo de ejecución. (/proc). Página 63. Utilidades I. Comandos de información. Página 65.

Actividad

1:

Actividad

2:

Actividad

3:

Actividad

4:

Actividad

5:

Actividad

6:

Actividad

7:

Actividad

8:

Actividad

9:

Actividad 10:

Actividad 11: Actividad 12:

Actividad 13:

Actividad 14: Actividad 15: Actividad 16:

Actividad 17:

Actividad 18:

3

Actividad 19:

Utilidades II. Comandos de compresión y descompresión de ficheros. Página 69. Archivos especiales de disp ositivos. Tipos y creación. Página 73. Sistema de ficheros. Montaje, sincronización y desmontado. Página 77. Introducción a la programación estructurada. Lenguaje C. Página 81. Aplicaciones de usuario: Compilado res. Tcc (Tiny C Compiler). Página 87.

Actividad 20:

Actividad 21:

Actividad 22:

Actividad 23:

Fin de actividades. <->

4

Actividad

0: Presentación de microLINUX. Características más relevantes.

¿Qué es microLINUX? ------------------MicroLINUX es una "Distribución" basada en LINUX, es decir, un sistema operativo (S.O.) formado por un núcleo (kernel) encargado de las tareas a más bajo nivel (cercanas al hardware): - Servicios de gestión de memoria - Gestión de procesos - Control de las operaciones de E/S, etcétera más un conjunto de aplicaciones: Entorno de trabajo (intérprete de comandos -shell-) Administración de usuarios Gestión del sistema de ficheros Utilidades orientadas a ficheros Desarrollo: Compilador C

Características --------------Al tratarse de una distribución suminist rada en un disquete, su contenido está fuertemente limitado por cuestión de espacio de almacenamiento. Esto ha obligado a prescindir de todo elemento gráfico así como de aplicaciones con un tamaño elevado. Sin embargo microLINUX sintetiza las cualidades propias de un sistema basado en LINUX: - Es multitarea - Es multiusuario - Es de libre distribución Requerimientos Hardware ----------------------MicroLINUX puede utilizar casi cualquier PC con microprocesador de la familia 80x86 ó equivalente. Está comprobado su correcto funcionamiento en un 486 DX a 40MHz y con 8 Mb de memoria RAM. Aunque puede funcionar con un 386 y coprocesador matemático. Intenciones ----------Probablemente desanime el hecho de que al arrancar microLINUX nos encontremos con un S.O. cuyo aspecto espartano (modo consola) nos recuerde al prehistórico MS-DOS y pensemos que se trata de un clon. Que no cunda el pánico. Esta distribución está pensada para ser utilizada por aquellas personas que quieren dar sus primeros pasos en LINUX sin temor a romper algo en el ordenador. Por otro lado todo lo que aquí se aprenda podrá manejarse en cualquier distribución basada en LINUX. Aunque algún comando o aplicación tenga un nombre diferente lo importante es saber qué ofrece LINUX y có mo puede el usuario hacer uso de ello.

<->

5

(En blanco)

6

Actividad

1: Acceso al sistema, ayuda en línea, cambio de sesión y cierre.

Pantalla de inicio -----------------Al arrancar microLINUX el usuario encuentra esta pantalla de inicio: +-------------------------------------------------------------------------- + | Bienvenido a microLINUX_VEM versión 1.0 | +-------------------------------------------------------------------------- + |Para comenzar: [microLINUX] login : root [Intro] | | + -------------------+ | | Ayuda de comandos | | Más información con: ayuda.sh | | | -------| #[comando] --help | | | | |Hay cuatro consolas, usar [Alt]+[Fn] (donde n 1...4) | Acaba microLINUX | |Reinicia el intérprete de comandos con: # exit | # halt ó | |Reinicia el sistema con: [Ctrl]+[Alt]+[Del] | # poweroff | +------------------------------------------------------ +-------------------+ [microLINUX] login:

Es importante que en la primera sesión el usuario dedique tiempo a leer el contenido de la ventana porque en ella aparece información útil para su trabajo con microLINUX. Acceso al sistema ----------------La primera acción consiste en identificarse al siste ma introduciendo 2 valores: 1º) login 2º) contraseña El "login" es el nombre que identifica al usuario en la sesión actual (contexto del S.O.). Para garantizar su autenticidad debe suministrar la contraseña asociada (cadena alfanumérica proporcionada por el administrador root-). En la configuración por defecto de microLINUX el único usuario con acceso al sistema es el propio administrador (root) sin contraseña, es decir, que tras escribir la cadena "root" y pulsar intro (< -) pasará directamente al intérprete de comandos (shell) y podrá empezar a interactuar con el S.O.. Cuando el acceso ha sido satisfactorio aparece en pantalla: [microLINUX] login: root Sep 14 16:09:14 login [30]: root login on 'tty1'

Busybox v0.60.5 (2004.04.26 -10:10+000) Built-in Shell (ash) Enter 'help' for a list of built -in Commands. # Señalando que el usuario ha sido validado satisfactoriamente y el sistema está a la espera de órdenes. El significado de la información suministrada es el siguiente: - Sep 14 16:09:14 hora y fecha de acceso.

7

- login [30]: root login on 'tty1' usuario root accede al sistema por la consola virtual 1 nota: microLINUX dispone de 4 consolas virtuales, es decir, que con una consola (teclado+pantalla) física es posible que el S.O. actúe como si en realidad hubiese 4. Dicho de otra forma microLINUX puede tener hasta 4 sesiones abiertas a la vez. - Busybox v0.60.5 (2004.04.26 -10:10+000) versión y fecha de compilación de la aplicación que en realidad implementa el intérprete de comandos. - Built-in Shell (ash) Intérprete de comandos -shell- ash nota: a diferencia de Windows en LINUX es posible encontrar varios intérpretes de comandos. El S.O. debe estar convenientemente configurado para usar, al menos, uno de ellos. - Enter 'help' for a list of built-in Commands. mensaje informativo: Al pulsar 'help' aparece la lista de comando internos reconocidos por el intérprete de comandos. Solicitud de ayuda -----------------MicroLINUX dispone de abundante documentación en línea. Escribiendo: #ayuda.sh ó #ayuda Aparecerá un menú autoexplicativo. cambio de sesión ---------------En cualquier momento el usuario puede pasar de una consola a otra (cambio de sesión) pulsando una combinación de teclas. Esta acción equivale a entrar en microLINUX desde otro ordenador. Los Sistemas Operativos basados en LINUX representan una versión "libre" de UNIX, utilizado en entornos corporativos donde es normal la interconexión de computadores formando redes y el acceso remoto a equipos. Para el cambio de sesión, pulsar la secuencia de teclas: <Alt>+<Fn> donde n puede ser 1, 2, 3 ó 4. Una sesión finaliza al escribir: #exit Indica a microLINUX que "desactive" la consola actual. En ese momento el S.O. solicitará los datos para una nueva sesión. consolas virtuales -----------------Cuando corre microLINUX en un PC, este simula a una máquina conectada a cuatro terminales manejados por personas diferentes. Para acceder al sistema, simplemente deben solicitarlo por medio de un cambio de sesión y val idándose con su nombre registrado "login" y la contraseña correspondiente. salida del sistema ------------------

8

Hay dos caminos para salir del sistema: Terminar y apagar el ordenador usando uno de estos dos comandos: # halt ó # poweroff Reiniciar el computador: - pulsando la secuencia de teclas <Ctrl>+<Alt>+<Del> Al salir del sistema, por ejemplo con ‘#halt’, sucede una cadena de acontecimientos que van desde la entrada del comando hasta desconexión total del equipo. El S.O. nos informa p untualmente de cada situación: #halt #swapoff /etc/fstab file missing the system is going down now !! Sending SIGTERM to all processes Sending SIGKILL to all processes the system is halted. Press Reset or turn off power flushing ide devices: hda hd b hdc system halted kernel panic: Attented to kill init ! --------------------------------------------------T R A D U C C I O N --------------------------------------------------#halt #swapoff /etc/fstab buscando fichero el sistema va a acabar ahora !! Enviando la señal de finalización (SIGTERM) a todos los procesos Enviando la señal de destrucción (SIGKILL) de todos los procesos El sistema está detenido. Pulsa el botón de reset o apaga el equipo Cerrando dispositivos ide (unidades de almacenamiento) del sistema hda hdb hdc Sistema detenido. Mensaje de pánico del núcleo: Intentado destruir el proceso init !

Ahora podemos apagar el equipo y sacar microLINUX de la disquetera. P R E C A U C I Ó N ------------------¡¡¡ NUNCA DEBE QUITARSE EL DISQUETE DE LA UNIDAD SIN INFORMAR AL S.O. ADECUADAMENTE, EN CASO CONTRARIO PODRÍAN DESTRUIRSE LOS DATOS QUE CONTIENE Y QUEDAR INSERVIBLE. !!! Se recomienda encarecidamente seguir los pasos indicados para un correcto funcionamiento del sist ema. T A R E A S ----------1º Salir de la sesión actual e intentar entrar con otro nombre de usuario. 2º Volver a entrar como root. 3º Abrir 3 sesiones diferentes como root. 4º Reiniciar el sistema (<Ctrl>+<Alt>+<Del>).

9

5º Solicitar ayuda al sis tema. Escribir ‘#ayuda.sh’ (usar el tabulador para pasar página). 6º Terminar la sesión y detener el sistema. ‘#halt’

<->

10

Actividad 2: La consola. Intérprete de comandos (shell), comandos internos (buil-in), comandos externos y aplicaciones. El concepto de consola ---------------------Entendemos por consola como la interfaz, en modo texto, entre un usuario y el sistema operativo por donde enviar las órdenes y recibir los resultados de las mismas. En un sistema de ordenadores conectados en red, la consola puede estar formada por un terminal que se encuentra físicamente separado del ordenador donde corre LINUX. En el caso de microLINUX el mismo computador ejecuta el S.O. y dispone de periférico de entrada y de salida por donde presentar las consolas de acceso (hasta 4) aunque únicamente es posible utilizar una en un instante determinado. Este efecto se logra por medio de la figura de los terminales virtual (tty1, tty2, tty3 y tty4) definidos en microLINUX y que representan diferentes medios de acceso al sistema aunque en realidad correspondan al mismo teclado y pantalla del computador. ¿Qué es el intérprete de comandos? ---------------------------------Es la utilidad más importante del sistema. Este es un programa que lee comandos escritos por el usuario y los ejecuta. También proporciona tareas de control de trabajos; Lo que permite al usuario realizar varias tareas a la vez. Redireccionar entradas y salidas (de / hacia la consola) y disponer de un lenguaje de programación para realizar guion es (scripts). Un guión consiste en un fichero con órdenes escritas en el lenguaje de programación del intérprete, semejante a los fichero por lotes (.bat) de MS -DOS. En microLINUX el intérprete es una versión adaptada de ash (también sh). Órdenes Internas ---------------Son comandos incluidos en el propio intérprete y por tanto no existen en el sistema en forma de ficheros, de hay su nombre en microLINUX: "comandos built-in" o comandos empotrados. Puede obtenerse un listado de las órdenes internas válidas escribiendo: # help Órdenes externas ---------------Ficheros del sistema que el intérprete ejecuta por mandato del usuario. Las órdenes externas extienden el poder del intérprete de comandos permitiendo un sistema operativo flexible y fácil mente adaptable a las necesidades de cada usuario. la forma habitual de llamar a una orden (interna o externa) es sencilla. En el indicativo del sistema el usuario escribe el nombre del comando y lo acompaña con los datos que necesite, también llamados parámetros. Tras pulsar intro el intérprete primero lo buscará en su lista de comandos internos y si no forma parte de ella consultará unos directorios determinados. Si la búsqueda fue fructífera ejecuta el comando con su parámetros, y en caso contrario entrega al usuario un mensaje de error. Sintaxis: #comando par_1 par_2 ... par_n <Intro>

11

Aplicaciones -----------Programas (compuestos a veces por varios ficheros -ejecutables y de configuración-) de usuario que le ayudan a sacar el máximo partido d el computador (y el S.O.) en su hogar, entorno profesional, etcétera. MicroLINUX dispone de una única aplicación de usuario: tcc (tiny c compiler), un compilador de lenguaje C (ANSI) completamente operativo. El usuario puede crear su propios programas es cribiéndolos en ANSI C y después compilándolos con esta utilidad (ver ayuda.sh ). Redirección y concatenación de órdenes -------------------------------------La ejecución de un comando sigue esta secuencia fija: desde el teclado (entrada estándar) el usuario escribe el nombre de la orden por ejecutar, después el intérprete de comandos toma la orden e intenta llevarla a cabo (puede ser un comando interno, externo o aplicación) tras lo cual presenta los resultados en la pantalla (salida estándar). Es posible modifica el orden de la secuencia redireccionando el proceso de ejecución. El formato es: - Carácter '>' para redireccionar la salida. Por ejemplo # orden_a_ejecutar > nueva_salida Donde nueva_salida puede ser un fichero. - Carácter '>>': igual que el caso anterior pero sin borrar lo que ya existiera en el destinatario. # orden_a_ejecutar >> acumula_nueva_salida También es posible concatenar dos (o más) comandos de tal manera que el resultado obtenido en la ejecución del primero sea l a entrada automática para el siguiente y así sucesivamente. El símbolo de concatenación es '|'. # comando_A | comando_B ... T A R E A S ----------1º Consultar los comandos internos del intérprete. Usar ‘# help’ 2º Ejecutar algún comando interno ( sin parámetros). Por ejemplo ‘# kill’ nota: algunos comandos necesitan ser acompañados por datos suministrados por el usuario. En la ayuda del intérprete la información viene expresada en un lenguaje propio. La sintaxis es: [dato] : Aquello que esté en tre corchetes es opcional. A | B : Equivale a decir A ó B (elegir una opción). -letra : El parámetro que acompaña al comando se escribe " -letra" 3º Usando la orden ‘# ayuda.sh’ buscar información sobre los comandos del sistema y la aplicación tcc. 4º Por medio del símbolo '|' concatena los comandos 'ls' y 'more'. <->

12

Actividad 3: Directorios de microLINUX. Creación, posición del usuario, cambio de ubicación, consulta de contenido y borrado de directorios. Ficheros y Directorios ---------------------Una de las primeras cosas que debe conocer el usuario de un PC es la diferencia entre el término fichero y directorio. Por un lado "fichero" representa el elemento mínimo de información presente en un ordenador accesible a partir de su nombre. Por otro "directorio" corresponde a un espacio con referencia única, dentro de las unidades de almacenamiento, donde alojar un conjunto de ficheros (de 0, 1 ó más elementos). Árbol de directorios en microLINUX ---------------------------------A diferencia de otros Sistemas Operativos las distribuciones basadas en LINUX (entre ellas microLINUX) disponen de una estructura bien definida de directorios que comúnmente denominaremos árbol de directorios. El nombre, posición y la misión que cumplen en las dif erentes implementaciones suelen ser los mismos. La jerarquía de directorios en microLINUX es: / | +-| +-| | +-| | | +-| | | +-| | | | | | | | | +-| +-| | +-| +-| +-| | /: Directorio raíz (root). bin dev bin: Directorio de binarios (ejecutables) del S.O.. dev: Lugar donde se encuentran los archivos descriptores de dispositivos. etc: Contiene archivos de configuración del sistema. init.d lib: Almacena librerías (ficheros con código ejecutable) compartidas por los binarios. teclado mnt: Espacio reservado para referenciar (montar y dar accesibilidad) a las unidades de almacenamiento. disquete | +-- boot | +-- dev | +-- var home: A partir de aquí comienzan los dir ectorios personales de cada usuario. proc: Directorio especial cuyo contenido se crea en tiempo de ejecución por el kernel donde el usuario puede visualizar los datos manejados por el núcleo. sbin: Almacena los ficher os binarios especiales del sistema. tmp: Encargado de contener los archivos temporales. usr: Reservado para aplicaciones de usuario (todos).

etc | +-lib | +-mnt | +--

home proc

sbin tmp usr | +-- bin

13

| | | | | | | | | | | | | | | | | +--

| +-| +-| +-| +--

sbin doc lib local | +-- bin | +-- include | +-- lib | +-- tcc var: Sitio donde están los ficheros del sistema que pueden cambiar de tamaño,(p.e. los manejados por el kernel, que guardan eventos o acontecimientos producidos durante una sesión -.log-).

var

¿En qué directorio me encuentro? -------------------------------Para conocer en todo momento la posición actual del usuario en el árbol de directorios debe utilizar el comando: pwd Cambio de ubicación y lectura de contenidos ------------------------------------------Cambio de directorio: cd ó chdir Ejemplos #cd /etc cambiar al directorio /etc #chdir /usr/local cambiar al directorio /usr/local Volcado en pantalla del lista do de ficheros de un directorio: ls Ejemplo #ls /proc visualización del directorio /proc

nota: Utilizar "ls --help" para conocer los modificadores admitidos por el comando. Creación y borrado de directorios (en el hogar del usuario) ----------------------------------------------------------Comando para crear directorios: mkdir Ejemplo #mkdir /home/varios ^ | comando ^ | directorio (con su localización absoluta)

Sin parámetros presenta información de ayuda (inglés). Comando para borrar directorios: rmdir Ejemplo #rmdir /home/varios Sin parámetros presenta información de ayuda (inglés).

14

T A R E A S ----------1º Comprobar si el árbol de directorio dibujado arriba corresponde al disponible en microLINUX. Duran te la exploración el usuario se situará en diferentes parte de la estructura y verificará su localización con "pwd". 2º Ver el contenido de los directorios con ficheros ejecutables: “/bin” y “/sbin”. 3º Crear y verificar el siguiente subárbol: /home/varios/pc / | +-- Hardware/ | | | +-- Placa_madre / | | | | | + -| +-- Disco_duro | | | +-- Lector_DVD | | | +-- RAM | | | +-- fuente_al | | | +-- Conectores | | | +-- Periféricos / | | | + -| | | + -| | | + -| +-- Software / | +-- Sis_op | +-- Aplicaciones

Chipset

Pantalla Teclado Ratón

4º Hacer uso de la utilidad de borrado de directorios creados por el usuario. Nota: ¡¡ trabajar siempre dentro del directorio /home !! <->

15

(En blanco)

16

Actividad 4: Tratamiento de ficheros I. Tipos (código de colores), creación, consulta, copia y borrado de ficheros. Expansión de nombres de ficheros. Tipos de ficheros, color asociado en la consola ----------------------------------------------Al listar los ficheros de un directorio con el comando "ls" (por ejemplo #ls /) estos aparecen po r pantalla ordenados y con un color determinado. Los colores identifican el tipo de fichero: Color ----verde blanco fucsia azul claro azul oscuro Tipo ---Script (Archivo con órdenes orientadas al intérprete) Archivo de texto Archivo especial asociado a dispositivo Enlaces a directorios o archivos Directorio

Formas de crear un fichero -------------------------Un fichero puede ser creado siguiendo tres métodos. 1º Crear un fichero vacío: touch Ejemplo #touch mi_fichero.txt Nota: para conocer el tamaño de un fichero es necesario que el comando "ls" venga acompañado de los parámetros " -s" ó "-s -h". Por ejemplo: #ls -s -h mi_fichero.txt . 2º Usar el editor de microLINUX: vi Ejemplo #vi mi_fichero2.txt Nota: consultar la ayud a del editor "vi" en "#ayuda.sh" 3º Redireccionar la salida estándar de la consola: echo Ejemplo #echo Saludos desde microLINUX > hola.txt Nota: El número máximo de caracteres admitidos para el nombre de un fichero al ser creado es 254. Visualizar el contenido de un fichero ------------------------------------Para observar el interior de un fichero utilizar el comando: cat Ejemplo #cat hola.txt (requiere el fichero hola.txt anterior) Copiar y borrar ficheros -----------------------Copiar un fichero con: cp Ejemplo #cp hola.txt copia_hola.txt Eliminar un fichero con: rm Ejemplo #rm copia_hola.txt

17

Mover un fichero ---------------Es posible cambiar la ubicación de un fichero en el árbol de directorios usando: mv Ejemplo #mv /home/agenda.txt /home/usuario1 En el ejemplo anterior “agenda.txt” pasa del directorio "/home" (fuente -source-) al directorio "/home/usuario1" (destino). Expansión de ficheros --------------------En microLINUX es posible seleccionar un conjunto de fich eros por medio de un reducido juego de caracteres y expresiones de sustitución: Comodines: '?' sustituye a cualquier carácter '*' sustituye a cualquier conjunto de caracteres Expresiones: - [AB] sustituye a expresiones con 'A' y con 'B'. Ejem plo: cad_a_[AB]_cad_b equivale a cad_a_A_cad_b cad_a_B_cad_b

- [A-Z] sustituye a expresiones con el rango de valores que van desde 'A' hasta 'Z' c_a_[A-C]_c_b sustituye a c_a_A_c_b c_a_B_c_b c_a_C_c_b - [^Z] sustituye a expresiones que NO T ENGAN 'Z'. También están permitidas las combinaciones de comodines y expresiones. T A R E A S ----------1º Buscar y sacar por pantalla algún fichero de tipo script. 2º Personalizar la distribución de microLINUX creando un fichero llamado “/home/propietario.txt” con tu nombre y apellidos. 3º Crear el directorio “/home/prueba” e incluir 2 ficheros vacíos. Posteriormente prueba a borrar el directorio. Ayuda: Tener clara la opción "-R" (recursivamente) del comando ‘rm’. 4º Hacer una copia de segurid ad (en /home/backups) de los ficheros de configuración alojados en “/etc”. 5º Haciendo uso de la expansión de ficheros, listar (comando 'ls') los ficheros de “/bin” que cumplan estas condiciones: Comiencen con la letra l. Comiencen con las let ras a, b, c, ó d. Contengan una h. Que no tenga ninguna letra m. Que Esté formado por 2 caracteres.

6º Mueve los ficheros del directorio "/home/prueba" al directorio "/home/backup". <->

18

Actividad 5: Proceso de arranque. Ficheros de configu ración e inicio en microLINUX. Proceso de arranque. ¿Qué sucede durante la carga del Sistema Operativo? -----------------------------------------------------------------------El proceso de arranque consiste en la sucesión de eventos que acontecen en el computador donde está instalado microLINUX desde el encendido del equipo hasta que el sistema solicita el nombre de usuario y su contraseña para comenzar una sesión. Es importante conocer estos sucesos porque en caso de un mal funcionamiento del sistem a es posible utilizar la información presentada para diagnosticar el origen del problema y facilitar así su corrección. Los pasos que microLINUX da en su inicio son: 1º El usuario inserta el disquete con el sistema operativo microLINUX y pulsa el botón de encendido. La BIOS del computador hace un chequeo del hardware. Si está todo OK buscará una secuencia de arranque en las unidades de almacenamiento que tenga configuradas para tal fin. 2º Suponiendo que la BIOS busque en primer lugar en la disquetera (ya que si lo hace en el disco duro iniciaría el S.O. allí instalado), leerá y ejecutará la secuencia de arranque que el gestor LILO (programa de entorno LINUX para crear y configurar el arranque de uno o varios sistemas operativos presentes en el PC) tien e allí depositado. 3º La secuencia de arranque carga en RAM el núcleo -KERNEL- y se ejecuta. Este kernel tiene como misión fundamental ser el intermediario entre los diferentes componentes hardware (unidades de almacenamiento, puertos, chipset, memoria RA M, etc.) y los comandos y aplicaciones de microLINUX. 4º Una vez situado el kernel en memoria principal, el siguiente paso es cargar el sistema de ficheros comprimido “micro_sf.gz”, también denominado sistema raíz (root system) donde está guardada toda la estructura de ficheros y directorios. 5º Se libera parte del espacio de memoria que ocupó inicialmente el fichero KERNEL de microLINUX (ayuda a optimizar este valioso, y en máquinas antiguas escaso, recurso). 6º El sistema de fichero se 'monta' descompr imido y queda operativo para microLINUX y los usuarios. A partir de ahora el S.O. hace uso de sus propios ficheros de configuración. 7º Ejecuta 'arranque.sh' (ver lilo.conf) encargado de preparar el disquete para que el usuario pueda utilizarlo y llamar a l proceso más importante (padre de todos los procesos): el proceso init. 8º Init tiene su propio fichero de configuración, 'inittab' el cual determina la última etapa del arranque. Desde aquí ordena a microLINUX presentar la pantalla de inicio y validar a l usuario 'root'. Configuración de inicio en microLINUX ------------------------------------El contenido de los ficheros implicados en el inicio del S.O. son, según el orden de uso: 1 ---> /mnt/disquete/lilo.conf #Configuración de arranque para micr oLINUX_VEM_1.0 - 2 Noviembre 2004 -

19

#Sistema de ficheros ext2 + puerto serie + puerto paralelo #Busybox + Tinylogin + Tcc + Ejercicios + Taller de LINUX boot =/dev/df0 install =/boot/bootsect map =/boot/map read-write backup =/dev/null image =/boot/KERNEL label =microLINUX root =/dev/fd0 initrd =/micro_sf.gz append ="root=/dev/ram0 prompt_ramdisk=1 init=arranque.sh" 2 ---> /arranque.sh #!/bin/sh /bin/mount -t ext2 /dev/fd0 /mnt/disquete exec /sbin/init 3 ---> /mnt/disquete/var/etc/init tab # ver información en busybox/scripts/inittab ::sysinit:/etc/init.d/rcS # cosas por hacer cuando reinicia el proceso init ::restart:/sbin/init # Carga texto de inicio ::wait:/etc/intro.sh # Inicia generando login sobre /dev/tty1 -4 tty1::respawn:/sbin/getty 38400 tty1 tty2::respawn:/sbin/getty 38400 tty2 tty3::respawn:/sbin/getty 38400 tty3 tty4::respawn:/sbin/getty 38400 tty4 # cosas por hacer antes de reiniciar ::ctrlaltdel:/sbin/reboot ::shutdown:/bin/umount -a -r ::shutdown:/sbin/swapof f -a 4 ---> /mnt/disquete/var/etc/intro.sh #!/bin/sh clear echo "+--------------------------------------------------------------------- +" echo "| Bienvenido a microLINUX_VEM versión 1.0 |" echo "+------------------------------ --------------------------------------- +" echo "|Para comenzar: [microLINUX] login: root [Intro] |" echo "| + -------------------+" echo "| | Ayuda de comandos |" echo "| Más información con: ayuda.sh | |" echo "| -------| #[comando] --help |" echo "| | |" echo "|Hay cuatro consolas,usa [Alt]+[Fn] (donde n 1..4)| Acaba microLINUX |" echo "|Reinicia el intérprete de comandos con: # exit | # halt ó |" echo "|Reinicia el sistema con: [Ctrl]+[Alt]+[Del] | # poweroff |" echo "+------------------------------------------------- +-------------------+" T A R E A S ----------1º Visualiza el contenido de los ficheros de configuración indicados. <->

20

Actividad 6: Tratamiento de ficheros II. Edición de ficheros de texto con editor vi. El editor vi -----------Cuando sea necesario crear, visualizar y/o cambiar el contenido de un fichero debe utilizar el editor ‘vi’ (VIsual editor). Programa editor clásico de Unix y LINUX. En realidad el editor ‘vi’ presente en microLINUX es una versió n reducida, adaptada para su uso en sistemas donde el tamaño es una cuestión crítica. El usuario notará que se encuentra frente a una herramienta muy sencilla pero limitada en prestaciones. Sin embargo es suficiente para las tareas expuestas en este tall er de LINUX. Entrar al editor ---------------Para abrir un archivo nuevo o ya existente utilizar: #vi nombre_archivo Dentro de vi -----------Una de las cosas más llamativa para los nuevos usuarios de ‘vi’ es el hecho de no poder empezar a escr ibir el contenido del fichero inmediatamente después de entrar en él. Esto es así porque ‘vi’ presenta 3 modos de trabajo: - Modo comando (por defecto al inicio del editor) - Modo inserción - Modo de última línea (pulsando ':') En el modo comando ‘vi ’ realiza acciones con el texto ya escrito según el comando (secuencia de uno o dos caracteres) indicado: Comando x dd ... i Acción Borra el carácter bajo el cursor Borra la línea en la que se encuentra el cursor (todos los comandos en 'ayuda.sh') Entra en el modo inserción (insertar texto en pantalla)

El modo inserción permite al usuario introducir el texto del fichero. Pulsando la tecla <Escape> vuelve al modo comando. El usuario conoce el “modo” en el que se encuentra porque aparece en la p arte inferior de la pantalla el mensaje '-- Insert --'. Nota: Si en alguna ocasión el usuario pulsa una tecla cuya función no es válida (por ejemplo la tecla <Inicio>) en ‘vi’, el editor responde con un mensaje de texto inverso (fondo blanco y letras en negro). En este caso simplemente debe pulsar <Escape> para salir del modo Inserción y después entrar de nuevo. Una vez terminada la sesión con el editor es preceptivo salir del sistema indicando la acción a realizar sobre el fichero. Para ello debe en trar en el modo “última línea”: Guardar el fichero Abandonar sin cambios -> 1º pulsa ':' y 2º 'w' 'nombre_nuevo_fichero'. -> 1º pulsa ':' y 2º 'q''!'.

21

Abandonar con cambios Busca patrón T A R E A S -----------

-> 1º pulsa ':' y 2ª 'x' ó 'w''q' -> 1º pulsa ':' y 2º '/''pa trón_a_buscar'

1º Abrir el fichero /home/propietario.txt y añadir los siguientes datos: - Estudios que está cursando en la actualidad. - Dirección de correo electrónico. 2º Crear un nuevo fichero denominado “/home/prueba.t xt” donde el usuario debe comprobar y utilizar, hasta que queden suficientemente claros, los diversos comandos y modos de ‘vi’. Recomendación: Con la segunda consola virtual, establecer una sesión en modo root y abrir la ayuda de vi -> “#ayuda.sh vi”. De esta forma, pasando de una consola a otra, es posible consultar los comandos de forma inmediata. 3º Por último crear el fichero “/home/resumen_comandos.txt” en cuyo interior deben aparecer listados los comandos usados hasta ahora acompañados de una breve descripción. <->

22

Actividad

7: Tratamiento de ficheros III. Enlaces duro y débil.

Concepto de enlace -----------------Los enlaces (links) permiten dar a un único fichero múltiples nombres. Los ficheros son identificados por el sistema con un número (nº de inodo), el cual es el único identificador del fichero para el sistema de ficheros. La orden: #ls -i Mostrará los números de "inodo". Enlace duro (hard link) ó enlace normal --------------------------------------La orden ‘ln’ es usada para crear múltiples enlaces a un fichero. Por ejemplo, suponer que tenemos un fichero llamado "agenda_tlfns" en el directorio actual. Usando 'ls -i' aparece en pantalla el número inodo para dicho fichero. #ln -i agenda_tlfns 43 agenda_tlfns Aquí, el fichero "agenda_tlfns" está asociado al número de inodo 43. Es posible crear un enlace a "agenda_tlfns", llamado tlfns: #ln agenda_tlfns tlfns Con 'ls -i' aparecen asociados los dos nombre al mismo número de inodo. Ahora, es posible acceder al contenido del fichero con los dos nombres. A todos los efectos, agenda_tlfns y tlfns son el mismo fichero. Solo es posible crear enlaces duros entre ficheros del mismo sistema de ficheros. Con el comando 'rm' usado sobre un enlace únicamente se elimina dicho enlace pero el fichero sigue existiendo; Para borrarlo definitivamente no deben existir otros enlaces en el sistema. La orden 'ln -l' sirve para conocer el número de enlaces a un fichero. Enlace débil o enlace simbólico ------------------------------Corresponde a otro tipo de enlace. Permite dar a un fichero otro nombre, pero no apunta al mismo número inodo. La orden: #ln -s fichero enlace_fichero Crea un enlace simbólico denominado "enlace_fichero" que apunta a "fichero". Utilizando 'ls -i' puede apreciarse como los dos ficheros tienen un número identificativo diferente. #ls -i fichero enlace_fichero 44 fichero 45 enlace_fichero Además aparece en color diferente "enlace_fichero" cuando se muestra el contenido del directorio con el comando 'ls'. Funcionalmente, los enlaces duros y simbólicos son similares, pero hay algunas diferencias. Por una parte, un usuario puede crear un enlace simbólico

23

a un fichero que no existe. También es posible enlazar simbólicamente con un archivo o directorio present e en otro sistema de ficheros. Por otro lado con la orden 'ls -l' puede verse el fichero apuntado. Cuando desaparece el fichero origen, todos los enlaces que apunta a él también son eliminados. Los enlaces simbólicos son los más flexibles y populares . Funcionan de forma parecida a los accesos directos de Windows 95/98 pero son mucho más potentes. T A R E A S ----------1º Crea el fichero "/home/usuario1/datos personales/agenda.txt" y en su interior almacena una lista de teléfonos (Nombre -- Dirección -Teléfono). 2º Enlazar (enlace simbólico) la agenda anterior con el fichero "/home/agenda_usuario1". 3º Utilizando el editor ‘vi’ modificar el contenido de agenda_usuario1. 4º Ver el contenido de "/home/usuario1/datos personales/agenda.txt". 5º Responder a esta pregunta tras crear los enlaces duros y simbólicos que considere oportunos: ¿Cuál es tamaño de los ficheros enlace (tanto duro como simbólico) cuando apuntan a otro con una capacidad de 1024 bytes?. Razona tu respuesta. <->

24

Actividad 8: Tratamiento de ficheros IV. Búsqueda, ordenación y extracción selectiva de datos. Búsqueda DE ficheros -------------------En microLINUX la utilidad 'find' es la encargada de realizar la búsqueda de ficheros y directorios dentro del sistema. Cuando el usuario desea localizar la ubicación de uno o más ficheros debe hacer uso del comando 'find' acompañado del correspondiente modificador. Algunas de las opciones son: - Listado de todos los ficheros (incluido su path) desde la posición actual en el árbol de directorios: #find - Listado de todos los directorios del sistema: # find / -type d - Listado de todos los enlaces: # find -type l - Búsqueda del fichero "fichero_perdido" desde el directorio raíz: # find / -name fichero_perdido Búsqueda EN ficheros -------------------También es posible la búsqueda de patrones (cadenas de caracteres) en el interior de un fichero. Esta labor la lleva a cabo el comando 'grep'. - Búsqueda de la fila del fichero agenda.txt que contiene la cadena "cadena_a_buscar": #grep cadena_a_buscar agenda.txt Ordenación DE ficheros ---------------------Para presentar por pantalla el listado de fichero de un directorio, según un criterio concreto, ordenado en modo ascendente o descendente, deben aplicarse los modificadores oportunos al comando 'ls'. Algunos ejemplos son: - Ordenar en orden inverso los ficheros del directorio actual: # ls -r - Ordenar los ficheros ordenados por extensión: # ls -X - Ordena los ficheros de todo el sistema de ficheros s egún su tamaño: # ls -S -R Ordenación EN ficheros ----------------------

25

El comando 'sort' imprime líneas de texto en orden alfabético u ordenadas por alguna otras regla que el usuario especifique. Todos los ficheros que acompañan al comando en la ord en son concatenados, y el resultado es ordenado y presentado por pantalla. Por ejemplo: - Ordenar el contenido de un fichero en orden descendente: #sort -r fichero_de_usuario - Ordenar numéricamente (primeros las líneas que empiezan por 0, luego las que comienzan con 1 y así sucesivamente): #sort -n fichero_de_usuario Extracción selectiva de datos en ficheros ----------------------------------------MicroLINUX ofrece la posibilidad de obtener parcialmente el contenido de un fichero en vez de mo strar el conjunto de la información. Existen tres posibilidades: 1ª Tomar las primeras (10 por defecto) líneas: Comando 'head'. 2ª Tomar las últimas (10 por defecto) líneas: Comando 'tail'. 3ª Extraer Columnas de texto de un fichero: Comando 'cut'. Una "columna" está definida por un conjunto de bytes, caracteres ó campos (por ejemplo el carácter que ocupa la posición 19 de cada línea). A continuación se muestran ejemplos de los comandos 'head', 'tail' y 'cut'. - Presenta las primeras 4 líneas de un f ichero: #head -n 4 fichero_de_usuario - Presenta las 4 últimas líneas de un fichero: #tail -n 4 fichero_de_usuario - Muestra el carácter décimo noveno de cada columna: #cut -c19 fichero_de_usuario - Muestra el byte nº 19 de cada columna: #cut -b19 fichero_de_usuario - En un fichero de texto donde cada línea tiene este formato: /----------+----------+---------------+-----=> Campos (fields) | | | | v v v v L1campo1 , L1campo2 , L1campo3 , .. , L1campoj L2campo1 , L2campo2 , L2campo3 , .. , L2campoj .. .. .. .. Lncampo1 , Lncampo2 , Lncampo3 , .. , Lncampoj ^ ^ ^ ^ | | | | \----------+----------+----+---------=> Delimitadores

26

Obtener el valor del campo 3 utilizando la coma como delimitador en vez de <Tab> (por defecto): #cut -d, -f3 fichero_con_campos - Obtener los primeros 6 caracteres de cada línea: #cut -c1-6 fichero_de_usuario - Obtener los caracteres que ocupan la posición 2, 4, 8 y 10 de cada línea: #cut -c2,4,8,10 fichero_de_usuario T A R E A S ----------1º Buscar la ubicación del comando 'find' en el árbol de directorios, haciendo uso de sí mismo. 2º Presentar en pantalla en orden inverso el contenido del directorio localizado en el punto anterior. 3º Crear un fichero que será utilizado como base de datos para almacenar una agenda de clientes. El formato y los campos debe tener esta forma: 1:Nombre:Apellido:Dirección:Teléfono:E -mail:Comentarios .. 9 ... E incluir 9 clientes. (nota: El fichero se llamará bd_clientes.txt, y debe existir un cliente con tu nombre) 4º Buscar las líneas que contengan tu nombre usando el comando 'grep'. 5º Listar los datos de los 3 primeros clientes en bd_clientes.txt. 6º Listar los datos de los 2 últimos clientes. 7º Listar el nombre de todos los clientes. 8º Listar ordenados de forma inversa todos los registros. 9º Presentar en pantalla las primeras 20 columnas de bd_clientes.txt. <->

27

(En blanco)

28

Actividad 9: Gestión de usuarios. Creación, propiedades y borrado de usuarios. Cambio de usuario. Gestión de usuarios ------------------Además de multitarea, todo los sistemas basados en LINUX incluido microLINUX deben tener capacidad para trabajar con varios usuarios. Un "usuario" identifica a una persona con derecho al acceso (total o restringido) y gestión en el sistema. Para ello es obligatorio que el administrador, conocido como 'root', le dé de alta y p roporcione una contraseña de acceso. Cuando un usuario está registrado en el sistema, puede acceder a él indicando dos datos: - Nombre de usuario: referencia del usuario definido por el administrador. - Contraseña: cadena de caracteres protegida asoc iada al nombre de usuario. El sistema operativo proporciona un espacio en el sistema de ficheros reservado a cada usuario llamado directorio de usuario donde puede desarrollar todas sus actividades libremente como crear ficheros, directorios, añadir aplicaciones, etcétera. Fuera de este entorno es posible que sus acciones estén limitadas según los permisos definidos por el administrador. El directorio desde donde "cuelgan" todos los usuarios es el directorio '/home'. Para que el administrador permita e l acceso a un usuario simplemente debe escribir: #login Posteriormente incluirá su nombre y clave de acceso. Incorporación de un usuario al sistema (creación) ------------------------------------------------El usuario "root" puede crear nuevos us uarios haciendo uso del comando 'adduser'. El único dato necesario es el nombre de usuario cuyo valor será utilizado para denominar su directorio "hogar". También es posible indicar otros valores durante el proceso de alta con el fin de personalizar el p erfil del nuevo usuario. Las opciones permitidas son: Nombre de directorio, Intérprete de comandos e identificador. Para crear un usuario nuevo llamado "cliente1" con los valores que el sistema asigna por defecto, el administrador usará la orden: #adduser cliente1 El sistema entregará el siguiente mensaje: Changing passwsord for cliente1 Enter the new password (minimum of 5, maximum of 8 characters) please use a combination of upper an lower case letters an numbers. Enter news password: _ - Traducción Cambiando contraseña para cliente1 Introduce la nueva contraseña (mínimo 5, máximo 8 caracteres) por favor utiliza una combinación de letras minúsculas y mayúsculas y números.

29

Introduce nueva contraseña: _ En este punto el administrado inco rpora la secuencia de caracteres que el sistema utilizará para validar al usuario durante el inicio de sesión. Como medida de precaución las letras y números escritos no aparecerán en pantalla para evitar que una persona ajena pueda aprovechar estos datos en beneficio propio. Después se comprueba la corrección de la contraseña escribiéndose de nuevo. De esta forma el sistema evita la entrada de valores no deseados por el usuario. Si todo el proceso terminó bien el sistema lo indica con el mensaje: Password changed (contraseña cambiada). Ahora el usuario con nombre de acceso "cliente1" tiene admitida su entrada al sistema y puede comprobarlo abriendo el terminal virtual 2 con <Ctrl> + <Alt> + <F2> y entregando los datos de acceso. Su situación en el sistema se confirma porque ahora el símbolo del intérprete de comandos a cambiado a: $ _ Puede "ver" su ubicación en el árbol de directorios escribiendo 'pwd'. Propiedades de usuario ---------------------A la hora de agregar un usuario con un per fil completo usar el comando 'adduser' así: #adduser -h /home/casa_cliente2 -s /bin/sh -g "usuario sin privilegios" cliente2 Los parámetro representan: -h : Nombre del directorio elegido para el cliente2, -s : Nombre del intérprete de comand os definido para el cliente2 -g : Datos de cliente2 Toda esta información quedará almacenada en el fichero de configuración "/etc/passwd" en donde por cada usuario, incluido el usuario "root", existe una línea con sus datos: campo1:campo2:campo3:campo 4:campo5:camp6:campo7 campo1: Nombre de usuario. campo2: Contraseña encriptada (si no tiene este campo aparece en blanco). campo3: identificador de usuario (uid) campo4: identificador de grupo (gid) campo5: Información de usuario campo6: Directorio de usuario campo7: Intérprete de comandos para este usuario Borrado de un usuario --------------------Cuando el administrado desea bloquear el acceso al sistema de un usuario llama al comando ‘deluser’:

30

#deluser nombre_de_usuario Entonces desaparece del fichero "/etc/passwd" su referencia y a partir de entonces queda imposibilitado para acceder al sistema. Cambio de contraseña -------------------Es posible que pasado un tiempo el administrador determine la necesidad de cambiar la contraseñ a de algún usuario. El comando encargado de esta tarea es ‘passwd’: #passwd usuario_de_sistema (nota: sin parámetro cambia la contraseña del administrador) En este momento el sistema solicitará la nueva contraseña dos veces (la segunda como confirmac ión). A partir de ahora el usuario está obligado a manejar la nueva contraseña si desea entrar en microLINUX. Cambio de usuario ----------------También está permitido cambiar de usuario en cualquier momento llamando a 'su' (switch user); En caso de no acompañar al comando con el nombre de un usuario, el sistema supondrá que es el usuario "root" quien pretende incorporarse. A continuación se entregará la contraseña de acceso del usuario entrante. El usuario único ---------------En los sistemas LINUX existe la figura del usuario único, encargado de realizar labores asociadas al mantenimiento del sistema. Cuando accede este usuario, el sistema queda inhabilitado para admitir simultáneamente otros usuarios. Esta pérdida (provisional) de la caracterís tica de multiusuario tiene como objetivo permitir al administrador disponer de TODO el sistema con el fin de realizar labores administrativa que de otra forma no sería posible. El usuario único se justifica sobre todo en aquellos entornos donde el sistema operativo corre en una máquina a la que acceden los usuarios desde diversos terminales. La activación del usuario único implica la imposibilidad de entrada a cualquier otra persona y garantiza que en ese instante el administrador tenga el uso y control d el sistema. El comando ‘sulogin’ valida el acceso en calidad de usuario único al sistema. MicroLINUX trata el usuario único (monousuario) como al usuario 'root'. En otras distribuciones es recomendable consultar: "El nivel de ejecución 1, modo monosuario". nota: El nivel de ejecución es cada uno de los diferentes estados en que se puede encontrar el sistema. Se identifican con un número o letra. ¿Quién soy yo? -------------En ocasiones cuando el administrador entra en el sistema repetidas veces registrándose como un usuario diferente en cada sesión, puede necesitar recordar su identidad, es decir, saber en un instante determinado el nombre de usuario activo en el sistema.

31

Esto se consigue con el comando 'whoami'. Tras ser ejecutado el S.O. devuelve el "login" actual. $whoami usuario1 $ El usuario como propietario de recursos (ficheros y directorios) ---------------------------------------------------------------Es posible proteger los ficheros de usuarios particulares de la manipulación por parte de otros. Todos los sistemas basados en LINUX proporcionan un mecanismo conocido como permisos de ficheros. Este método permite que ficheros y directorios "pertenezcan" a un usuario determinado. El comando encargado de cambiar el dueño de un recurso es 'chown'. Por ejemplo si el administrador desea asignar como propietario del fichero "/home/datos_usuario1" al usuario 'usuario1' escribirá: #chown usuario1 /home/datos_usuario T A R E A S ----------1º Crear un usuario con los parámetros p or defecto con nombre usuario_normal. 2º Crear un usuario con estas características: - Directorio /home/dir_usuario - Identificación "usuario personalizado 1" - Intérprete "/bin/sh" 3º Crear un usuario normal con nombre usuario_provisional. 4º Abrir las consolas virtuales 2, 3 y 4 para acceder como los usuarios creados en 1, 2 y 3. 5º Ahora el usuario_provisional debe abandonar su sesión. (Utiliza el comando exit). 6º Consultar el fichero donde están los datos de usuario "/etc/passwd". 7º Eliminar el usuario usuario_provisional. 8º Intentar acceder como usuario_provisional en la consola virtual 4. 9º Consultar de nuevo el fichero de configuración de usuarios. 10º Usar en la consola virtual 1 el comando 'su' para cambiar de usuario. 11º Ahora, intentar suprimir el acceso a usuario_normal. ¿Es posible?, razona tu respuesta. 12º Consultar el nombre del usuario actualmente registrado. 13º Como administrador, crear el fichero "/home/dir_usuario/datos_usuario_normal.txt" y cambiar el propietario a usuario_normal. <->

32

Actividad 10: Concepto de grupo. Creación y borrado de grupos. Agregación y eliminación de usuarios a un grupo.

Concepto de grupo ----------------La idea de grupo es la de establecer equipos de trabajo que nec esitan acceso a recursos comunes. Así un programador (perteneciente al grupo de programadores) puede reservarse el permiso de escritura sólo para él pero permitir a sus compañeros de equipo que lean sus ficheros fuente y no permitir a nadie más (otros) que hagan nada. Trabajo con grupos -----------------Cada usuario es miembro de un grupo. Pueden darse distintas posibilidades o privilegios a distintos tipos de usuarios. Por ejemplo parece más lógico dar acceso a diferentes tipos de archivos a un grupo que utiliza el sistema para analizar las ventas de la compañía, que a otro cuya tarea principal es la investigación de nuevos productos. El archivo de contraseñas, tal y como se indicó en el apartado anterior, "/etc/passwd" guarda información de cada us uario. Los datos sobre los grupos se almacenan en el archivo "/etc/group". Ejemplo de registro de un grupo en ese archivo: #cat /etc/group root:x:0: usuario:x:508: cli:x:509:cliente1,cliente2 pro:x:510:provee1,provee2,provee3 Cuando el administrado r da de alta un usuario, el sistema también añade una nueva línea al fichero "/etc/group" señalando que hay un grupo específico para el nuevo registro. Por ejemplo: #adduser nuevo_usuario ... >>> contraseña de validación ... #cat /etc/group root:x:0: usuario:x:508: cli:x:509:cliente1,cliente2 pro:x:510:provee1,provee2,provee3 511:x:511:nuevo_usuario

<-- Nuevo grupo

El significado de los campos que componen el fichero "/etc/group" es el siguiente: campo1:campo2:campo3:campo4 campo1: Nombre del grupo. campo2: Contraseña encriptada de grupo. En blanco indica que no hay contraseña y una 'x' señala que la contraseña es accesible SOLO al administrador 'root' en el fichero "/etc/gshadow" (este fichero no existente en microLINUX aunque sí en otras distribuciones).

33

campo3: Número de identificación -GID- del grupo. campo4: Lista de usuarios pertenecientes al grupo. La configuración de grupos en microLINUX puede llevarse a cabo por dos caminos distintos. Uno es editar el fichero usado por el S.O. para la gestión de grupos "/etc/group" y realizar sobre él las modificaciones oportunas. Por otra parte pueden emplearse los comandos que a tal efecto dispone microLINUX y se muestran a continuación. Creación de grupos -----------------La utilidad 'addgroup' incluye un nuevo grupo. Si el identificador de grupo (GID) no está indicado, 'addgroup' intentará encontrar el siguiente GID válido en "/etc/group" dentro del rango [100..6400]. Ejemplo: Dar de alta el grupo 'lectores'. #addgroup -g lectores Ejemplo: Dar de alta el grupo 800 (con GID 800) e indicar que el usuario 'lector1' pertenece a él. #addgroup -g 800 lector1 Ejemplo: Dar de alta el grupo escritores al que pertenece escritor1. #addgroup -g escritores escritor1 Borrado de grupos ----------------Para borrar un grupo simplemente debe llamarse al comando 'delgroup' y acompañarlo del nombre del grupo que se quiere eliminar. Ejemplo: Borrar el grupo 800. #delgroup 800 Cambio de grupo --------------Cuando sea necesario cambiar el grupo al que pertenece un recurso (fichero ó directorio) debe aplicarse el comando 'chgrp'. Además del recurso, hay que acompañar como parámetro el nuevo grupo propietario. La forma de llamada es la siguiente: #chgrp Nuevo_grupo Nombre_recu rso nota: añadiendo el parámetro -R cambia el grupo recursivamente a los recursos (ficheros y directorios) contenidos en Nombre_recurso. Modificación de usuarios pertenecientes a un grupo -------------------------------------------------Si el administrador del sistema desea cambiar la lista de usuarios relacionados con un grupo, necesita editar el fichero "/etc/group" y modificar su contenido. T A R E A S -----------

34

1º Como administrador hay que crear tres nuevos grupos en el sistema: clien (clientes), prove (proveedores) y usuarios. 2º Verificar la existencia de los nuevos grupos consultando el fichero "/etc/group". 3º Generar los directorios "/home/usuarios", "/home/usuarios/dir_cli" y "/home/usuarios/dir_pro". 4º Cambiar la pertenencia a grupo de los anteriores directorios según este criterio: /home/usuarios /home/usuarios/dir_cli /home/usuarios/dir_pro --> grupo usuarios --> grupo clien --> grupo prove

5º Añadir los siguientes usuarios: 'cliente1', 'cliente2', 'proveedor1', 'proveedor2' y 'proveedor3'. 6º Configurar el sistema para que 'cliente1' y 'cliente2' pertenezcan a 'clien' así como que los usuarios 'proveedor1', 'proveedor2' y 'proveedor3' correspondan al grupo 'prove'. Los directorios asociados 'cuelgan' de "/home/usu arios". 7º Por último comprobar la correcta estructura jerárquica de los nuevos directorios: /home/usuarios/cliente1 cliente2 proveedor1 proveedor2 proveedor3 dir_clien/ dir_prove/ nota: No borrar los datos creados en este apartado porque son necesarios en la actividad siguiente. <->

35

(En blanco)

36

Actividad 11: Permisos en un sistema multiusuario. Introducción -----------La seguridad de un sistema derivado de LINUX se basa en el sistema de permisos y propiedades de los ficheros. Es importante mantener una buena política de seguridad aún cuando sólo hay un único usuario. Un usuario normal encontrará pocos problemas de permisos con sus ficheros de uso diario. Pero para un administrador las cosas son más complicadas. Asignando un permiso erróneo se verá inmerso en una serie de frustrantes experiencias como, por ejemplo, la imposibilidad de leer ficheros "propios". El mensaje: Permission denied Es decir, permiso denegado, indica que algui en ha asignado un permiso que nos restringe el acceso más de lo que quisiéramos. ¿Qué son los permisos? ---------------------Los permisos hablan de lo que un usuario puede hacer con un recurso (fichero ó directorio). Hay tres tipos de permisos: - r Lectura: El permiso indica que el usuario puede ver el contenido del archivo (r read, leer). - w Escritura: El usuario puede escribir en el archivo o bien borrarlo (w write, escribir). - x Ejecución: Cuando el fichero es un programa el usuario puede ejecutarlo (x execute, ejecutar). Con un archivo nuevo, el sistema asigna automáticamente unos permisos. Por ejemplo le permite al autor del archivo leer y escribir en él, pero al resto de los usuarios solamente leerlo. Los programas que crean archivos asig nan a estos los permisos correspondientes. Así, cuando el compilador crea un programa ejecutable, automáticamente le asigna el permiso de ejecución. Con los directorios, los permisos tienen un significado algo distinto: - El permiso de lectura indica q ue se puede listar el contenido del directorio. - El permiso de escritura significa que se puede añadir o borrar ficheros al directorio. - El permiso de ejecución quiere decir que se puede consultar información de los archivos del directorio. También hay otro tipo de recursos (ficheros especiales) como los especiales de dispositivos, los enlaces simbólicos, etc. cada uno tiene sus propias reglas de interpretación de los permisos. ¿A quiénes se les dan los permisos? ---------------------------------- En un sistema LINUX están presentes tres categorías de permisos: propietario (owner), grupo (group) y otros (others). Por tanto los elementos básicos en cuanto a seguridad se refiere son: tres permisos (lectura, escritura y ejecución) y tres niveles (p ropietario, grupo y terceros). Lectura de los propiedades de un recurso ----------------------------------------

37

Utilizar 'ls -l' para conocer los permisos y pertenencia asociados a un recurso. Por ejemplo, ¿que permisos tiene el fichero"/etc/passwd"?: #ls -l /etc/passwd -rwxr-xr-x 1 root root 553 Oct 14 16:49 /etc/passwd ^ ^ ^ ^ ^ ^ ^ | | | | | | | | | | | | | + --- Recurso | | | | | | | | | | | + --- Fecha y hora del | | | | | último cambio | | | | + --- Tamaño en bytes | | | | | | | + --- Grupo al que pertenece el recurso | | | | | + --- Propietario | | | + --- nº de nombres del fichero (ver enlace simbólico | -actividad 7-) +--- Permisos Permisos: Representación -----------------------Al listar los permisos de un r ecurso estos aparecen codificados según el siguiente formato: - rwx rwx rwx ^ ^ ^ ^ | | | | | | | | | | | +--| | | | | +------| | | +----------| +-------------Con 'letra' tiene el permiso correspondiente, con ' -' no.

Permisos a otros usuarios Permisos al grupo que pertenece Permisos que tiene el propietario Tipo de recurso: d l c b Directorio Enlace Fichero normal Fichero especial (tipo carácter) Fichero especial (tipo bloque)

Ejemplos: drw-r--r-- --> Directorio cuyo propietario puede leer y escribir, mientras que los miembros del grupo al que pertenece solo leer, como el resto de usuarios. -rw-r----- --> Fichero normal que puede ser leído por su propietario y el grupo asociado. El dueño también tiene permiso de modificación y borrado. Cambio de pertenencia y permisos de un recurso ---------------------------------------------Pertenencia: La mayoría de las veces podemos confiar en los ajustes predeterminados del sistema. No obstante hay ciertas excepciones.

38

Como se ha visto en las actividades anteriores, las modificaciones de propiedad se hacen con: - chown -> Cambio de propietario (sólo 'root' puede utilizar este comando). - chgrp -> Cambio de grupo (un usuario norm al puede aplicarlo a recursos que le pertenezcan). Pueden hacerse estas dos cosas en un solo paso empleando el punto '.': #chown cliente1.cli agenda_cliente1 Permisos: La forma de cambiar los permisos es algo más complicada. A los permisos se les suele llamar el 'modo' de un archivo. Para cambiar se emplea el comando 'chmod' (change mode -cambio de modo-). El comando 'chmod' reconoce varios caracteres y signos utilizados a modo de parámetros combinados para determinar el nuevo estado de los permi sos del recurso. Estos caracteres son: | Ámbito| | | u g o a --> --> --> --> user (usuario) group (grupo) others (otros) all (todos)

| + --> Añade un permiso Acción| - --> Elimina el permiso | = --> Activa permisos absolutos ignorando los exi stentes | | | | | r w x s t --> --> --> --> --> Permiso Permiso Permiso Permiso Permiso de lectura de escritura/modificación de ejecución (en directorios indica el acceso) condicionado -nota 1condicionado -nota 2-

Tipo

nota 1: Modo Setuid : La identidad efectiva de usuario con la que se ejecuta el programa es la del propietario del mismo (usar con ejecutables). Modo Setgid : el comportamiento es igual que el anterior pero afectando al grupo. nota 2: Sticky -pegajoso- bit (aplicado a directori os) [chmod +t directorio] Útil para aquellos programas que se ejecutan a menudo y por diferentes usuarios. Permite que sólo el propietario del fichero, el propietario del directorio ó el administrador puedan renombrar o borrar los ficheros contenidos en é l. El formato del comando 'chmod' sería: #chmod ámbito (único o múltiple) AcciónTipo (admite más un tipo). Por ejemplo: --> Permiso de lectura escritura y ejecución para usuario y grupo #chmod g-x fichero_principal --> Elimina el permiso de ejecución al grupo (deja el resto como está) #chmod =r fichero_lectura --> Únicamente permite la lectura de todos los usuarios También es posible presentar la codificación de los permisos usando notación octal según el siguiente formato: #chmod ug+rwx fich_principal

39

+--- Propietario | | +--- Grupo | | | | +--- Otros | | | v v v rwx rwx rwx 111 111 111 <-- Equivalente Binario ('1' permiso activo, '0' denegado) 7 7 7 <-- Equivalente Octal

En este formato se encuentran implícitos tanto el ámbito como el tipo. Tomando los ejemplos anteriores su representación sería: #chmod 770 fichero_principal (equivale a #chmod ug+rwx ) #chmod 670 fichero_principal #chmod 444 fichero_lectura Si el deseo es configurar un directorio donde cada usuario pueda borrar los archivos que le pertenecen o bien el dueño del directorio así como el administrador, utilizar: #chmod +t directorio_especial Como último ejemplo se habilitarán permisos a un fichero ejecutable de tal modo que un usuario normal pueda llamarle y corra como si hubiese sido activado por el administrador. #chmod u+s ejecutable_usuario1 T A R E A S ----------1º A partir del subdirectorio "/home/usuarios" creado en la actividad anterior establecer la jer arquía de permisos y propiedad siguiente: Propietario ----------usuario cliente1 cliente2 proveedor1 proveedor2 proveedor3 usuario usuario Grupo ----usuario cli cli pro pro pro cli pro Permisos -------drwxr-sr-x drwxr-x--drwxr-x--drwxr-x--drwxr-x--drwxr-x--drwxrwxr-t drwxrwxr-t

/home/usuarios/ cliente1 cliente2 proveedor1 proveedor2 proveedor3 dir_clien/ dir_prove/

--> --> --> --> --> --> --> -->

2º Comprobar la correcta asignación con el comando "#ls -l". 3º Tomando la identidad de los usuarios que tienen cuenta en el sistema acceder y crear tanto ficheros como directorios donde después se comprobará el correcto tratamiento de los permisos por parte del S.O.. <->

40

Actividad 12: Procesos en linux. Estado de un proceso. Ejecución en primer y segundo plano. Procesos en LINUX ----------------El intérprete de comandos tiene como misión atender las órdenes lanzadas por el usuario sobre la consol a, aunque también se encarga del CONTROL DE TAREAS; Trabajo consistente en gestionar la correcta ejecución de todos los comandos y programas que acontecen en cada instante. Cuando un usuario ejecuta un programa, lanza lo que se conoce como proceso, que es simplemente el nombre que se da a un programa que se está ejecutando. El comando 'ps' visualiza la lista de procesos activos actualmente. Por ejemplo: #ps PID 1 2 3 4 5 6 30 31 32 22 33 # El significado de cada columna es: - Columna "PID" representa el identificador del proceso. - Columna "Uid" señala el usuario (uid -identificador de usuario -) que lanzó el proceso. - Columna "Size" tamañ o del proceso. - Columna "State" informa del estado de un proceso. Los valores posibles son: - R (Runnable): En ejecución. - S (Sleeping): Durmiendo. Espera un suceso del sistema. - T (Traced ó Stopped): Detenido. Está parado por una señal indicada por el proceso que lo llamó (proceso padre) generalmente el intérprete de comandos por orden del usuario. - Columna "Command" contiene el nombre del proceso que se está ejecutando. Estados de un proceso --------------------Durante la ejecución de un proceso este puede pasar por diferentes estados. El estado de un proceso define cual es su actividad en un momento determinado. A continuación se muestran tres posibles situaciones: A) Ejecución normal de un proceso. llamada al proceso --> Ejemplo: Ejecución --> Fin (R) TTY Uid root root root root root root root root root root root Size 620 0 0 0 0 0 620 496 496 612 608 State S S S S S S S S S T R Command init [keventd] [ksoftirqd_CPU0] [kswapd] [bdflush] [kupdated] -sh /sbin/getty 38400 tty2 /sbin/getty 38400 tty3 vi ps

tty1 tty2 tty3 tty1 tty1

41

#date Sun Oct 24 18:16:27 UTC 2004 #_

<-- Llamada al proceso <-- Ejecución <-- Fin del proceso, el sistema espera nueva orden

B) Detención de un proceso. llamada --> Run --> [Señal de stop] ... ... --> Run --> Fin (R) | ^ (R) | | v | Parada ...[activar] --+ (T) Ejemplo: #vi fichero_usuario ... pantalla del editor ... <Ctrl>+<Z> %1 Stopped # ... #bg ... pantalla del editor ... # <-- Llamada al proceso <-- Ejecución <-- Parada del proceso

<-<-<-<--

Otros proceso Activación del proceso detenido Ejecución Fin del proceso, el si stema espera nueva orden

C) Proceso durmiente. llamada --> Ejecución --> Espera ... [ ] --> Ejecución --> Fin (R) (S) ^ (R) | | Evento Ejemplo: En el caso de proceso en estado durmiente el eve nto esperado es una señal entregada por el Sistema Operativo. Ver con el comando 'ps' como las consolas virtuales tty2 y tty3 son procesos en esta situación a la espera de ser activadas. El usuario puede forzar el estado de un proceso manejando los coman dos y opciones del intérprete de comandos siguientes: - Ver el estado de las tareas en segundo plano y detenidas por el usuario con el comando 'jobs'. Por ejemplo: #jobs [1] 52 yes > /dev/null [2] 53 Stopped vi fichero_2 ^ ^ ^ ^ | | | | | | | +--- Tarea | | | | | +--- Estado de la tarea | | | +--- Número de identificación del proceso (PID) cuando se | lanzó +--- Número de tarea en situación de parad a o ejecución en segundo plano - Detener un proceso, pulsado la combinación de teclas <Ctrl>+<Z>. Por ejemplo:

42

#vi fichero_2 ... pantalla editor ... <Ctrl>+<Z> %1 Stopped ... #fg (el editor vi retorna a estado de ejecución) nota: Mientras un proceso está "durmiendo" no se ejecuta y por tanto no consume CPU. - Forzar la finalización de un proceso, usando la combinación de teclas <Ctrl>+<C>: #yes > /dev/null _ <Ctrl>+<C> # <-el programa "yes" lanza el mensaje por consola "y" en un bucle in finito (la salida está redireccionada al dispositivo nulo -equivale a la papelera en windows -)

Nota: La combinación <Ctrl>+<C> es efectiva sobre procesos en primer plano. - Eliminar un proceso por medio del comando 'kil l'. Admite como parámetros: El nº de tarea (según 'jobs') precedido por "%" Ejemplo: #kill %1 El nº identificador de proceso (PID) Ejemplo: #kill 40 Ejecución en primer y segundo plano ----------------------------------Ya se ha comentado la capa cidad multitarea (varias acciones realizadas a la vez) de todo sistema LINUX. Pero ¿cómo conseguir esto si únicamente es posible interactuar con una tarea en un instante determinado?. Los conceptos primer y segundo plano describen esta situación. Decimos que un proceso está en primer plano cuando es accesible desde la consola mientras que el resto de procesos activos están ejecutándose fuera de ella, es decir, en segundo plano. El Sistema Operativo proporciona herramientas con las que trasladar manualmente un proceso en ejecución de primer a segundo plano y viceversa, es decir, el usuario puede elegir de entre los procesos activos aquel con el que desea interactuar. El comando 'fg' (ForeGround) pasa a primer plano una tarea suspendida o en segundo plano. Sin argumentos, selecciona la tarea suspendida más recientemente. La selección de una tarea particular, suspendida o en segundo plano, (ver las tareas con el comando 'jobs') se hace con el número de tarea precedido del signo de tanto por ciento "%". Ejemplos: #fg #fg %2 <-- Pasa la tarea suspendida a primer plano. <-- Lleva a primer plano la tarea 2 (según 'jobs').

Una tarea suspendida es puesta en ejecución en segundo plano utilizando el comando 'bg' (BackGround). Sin argumentos, 'bg' opera c on la tarea que fue suspendida más recientemente. Puede especificarse una tarea determinada (ver las tareas con el comando 'jobs'), aportando el número de tarea precedido del signo de tanto por ciento "%".

43

Ejemplos: #bg <-- Pone en ejecución en segundo plano la última tarea suspendida. #bg %2<-- Pasa la tarea 2 a ejecución en segundo plano (según 'jobs'). En LINUX también es posible iniciar un programa directamente en segundo plano, escribiendo el signo "&" (en inglés "ampersand") al final de la líne a de órdenes durante la llamada a la tarea. Por ejemplo: #vi mi_fichero & T A R E A S ----------1º Ejecutar las tres órdenes siguientes en primer plano y pásalas a estado suspendido: #yes <Ctrl>+<Z> #yes bucle infinito 2 <Ctrl>+<Z> #yes bucle infinito 3 <Ctrl>+<Z> 2º Estudiar el estado de las tareas con el comando 'jobs'. 3º Eliminar el proceso que fue lanzado con la orden "#yes". 4º ¿Qué sucede si ahora deseo pasar a primer plano el proces o eliminado en el punto anterior?. Inténtalo con "#kill %1". 5º Revisa el estado de las tareas ('jobs'). 6º Puesto que los bucles infinitos 2 y 3 se ejecutan en segundo plano intenta terminarlos (<Ctrl>+<C>). 7º Visto que es imposible, pasar el bucle i nfinito 2 a primer plano y repetir el punto anterior. 8º Lanza un bucle infinito (4) directamente a segundo plano redireccionando los mensajes de salida a nulo: #yes bucle infinito 4 > /dev/null & 9º Comprueba el estado de los procesos. 10º Elimina todas las tareas suspendidas o ejecutadas en segundo plano: kill %a %b ... %x (a,b,..,x según 'jobs'). <-> <-- Lanza el editor "vi" en segundo plano.

44

Actividad 13: Scripts I. Ficheros de usuario ejecutados por el intérprete de comandos. Variables de entorno. Introducción -----------El intérprete de comandos no es sólo un programa encargado de tomar las órdenes escritas por el usuario y llamar al comando o aplicación correspondiente trasladándole los parámetros deseados. También dispone de mecanismos para la automatización y administración de tareas en el sistema donde la eficiencia es menos importante que la fácil configuración, mantenimiento y portabilidad. Todo esto se traduce en la definición de un lenguaje de programación propio donde el intérprete ejecuta ordenadamente las acciones recogidas en un guión ("script") escrito por el usuario siguiendo la sintaxis presentada en los siguientes apartados. ¿Qué es un Script? -----------------Un Script es un fichero de texto escrito por un usuario con órdenes para el intérprete de comando s. Cuando se llama al fichero todas las acciones se ejecutan automáticamente siguiendo el patrón definido en él. En MS -DOS equivaldría a un fichero por lotes .BAT. En su interior, el fichero contendrá obligatoriamente en la primera línea esta secuencia: #! /bin/sh

Donde - "#!" identifica al fichero como guión ejecutable por el intérprete de comandos. - "/bin/sh" especifica el intérprete del guión. (En un S.O. LINUX pueden convivir varios intérpretes). Un Ejemplo sería: #! /bin/sh echo hola mundo.

# presenta por pantalla la cadena "hola mundo." ^ | +-- Marca el comienzo de un comentario (no lo tiene en cuenta el intérprete) hasta el final de la línea.

El nombre del fichero puede ser cualquiera (usar .sh) y tras su creaci ón es necesario convertirlo en ejecutable cambiando sus propiedades: #chmod +x fichero_script.sh La llamada al script necesita estar precedida de la cadena "./": #./fichero_script.sh El Sistema Operativo identifica un script usando el color verde a l listar los ficheros del directorio que lo almacena. Elementos de un Script ----------------------

45

En un guión puede aparecer cualquier orden válida para el indicativo del sistema: Comandos con sus parámetros llamada a una aplicación Redirecciones de salida y/o entrada Concatenación de órdenes Uso de caracteres de sustitución (comodines), etc.

Además incluye otras capacidades: - Manejo de variables - Ampliación de comandos - Tratamiento de argumentos del script - Comandos de sustitución - Expansión aritmética - Estructuras de control - Estructura condicional (si ... no) - Estructura iterativa (repetir ...) - Selección de opciones (En caso de ...) - Funciones Aunque existe abundante bibliografía sobre el "arte" de la c reación de scripts aquí sólo se mostrarán algunas pinceladas de las diversas opciones apuntadas. Manejo de variables ------------------Una variable es la referencia a una zona de la memoria cuyo contenido es manejado dentro del guión . Al iniciar la ejecución de un Script también son accesibles todas las variables del intérprete de comandos (llamadas variables de entorno). Las variables de entorno se muestran en pantalla gracias al comando ‘env’, por ejemplo: # env USER=root OLDPWD=/ HOME=/ LOGNAME=root TERM=linux PATH=/usr/sbin:/bin:/usr/sbin/:/sbin SHELL=/bin/sh PWD=/home Donde la palabra en mayúsculas es el nombre de la variable y la cadena de caracteres a la derecha del signo "=" representa la información que almacena. Cuando sea necesario operar con el contenido de cualquier variable dentro de un Script hay situar el símbolo dolar "$" delante de su nombre. Ejemplo, contenido del fichero "scrpt1.sh": #! /bin/sh echo Estoy en el directorio $HOME

# mensaje de texto por pantalla.

Al ejecutar el script (recordar, 1º pasar a ejecutable -# chmod +x scrpt1.sh- y 2º llamar con ./script.sh) el resultado en pantalla es:

46

#./script1.sh estoy en el directorio /home # También un guión puede definir sus propias variables: ... dentro de un guión ... nombre_variable=contenido <-- No dejar espacios en extremos de "=".

Si la cadena de caracteres almacenada en la variable tiene espacios en blanco es necesario expresarla entre los símbolos de doble comilla. Ejemplo, contenido y ejecución del fichero "scrpt2.sh": #! /bin/sh variable1=cadena_sin_espacios variable2="cadena con espacios" echo $variable1 echo $variable2 sleep 3 #./scrpt2.sh cadena_sin_espacios cadena con espacios # _ Las variables creadas (y su valor) en un guión desaparecen al finalizar la ejecución del mismo. Otro ejemplo. Contenido del fichero "scrpt3.sh": #! /bin/sh mensaje1=uno mensaje2="$mensaje1 dos" # Es posible anida r variables dentro de otras mensaje3="$mensaje2 tres"# :var_x="...$var_y..." echo $mensaje3 sleep 3 #espera 3 segundos y continúa Al ser ejecutado aparece en pantalla: #./scrpt3.sh uno dos tres # _ Una última consideración. Es después de una variable sin que el posible recurriendo al aislamiento de llave {nombre_variable}. Ver el scrpt4.sh: posible escrib ir caracteres inmediatamente intérprete los asocie a ella. Esto es del nombre de la variable con los símbolos contenido y ejecución del fichero

#usar dobles comillas cuando hay espacios #espera 3 segundos y continúa

#! /bin/sh frecuencia=4.0 echo El PIC 16F84 trabaja a una velocidad de ${frecuencia}MHz #./scrpt4.sh El PIC 16F84 trabaja a una velocidad de 4.0MHz # _ T A R E A S ----------1º Crear y ejecutar todos los scripts de esta actividad.

47

2º Preparar un script llamado "mi_script.sh" que realice estas acciones: - Liste por páginas el contenido del directorio marcado por (/bin). - Cree una copia de sí mismo en el fichero copia_mi_script.bkp usando el elemento de redirección ">". Y presente por pantalla los siguientes datos: - Nombre del intérprete de comandos (SHELL). - Directorio actual (PWD). - Usuario (USER). <->

48

Actividad 14: Scripts II. Ampliación de comandos y Funciones. Ampliación de comandos ---------------------Tal y como se apuntó en la actividad anterior los scripts permiten aumentar las capacidades vistas hasta ahora del intérprete de comandos. Dentro de la ampliación de comandos existen tres apartados diferentes: - Tratamiento de argumentos del script - Comandos del sustitución - Expansión aritmética Tratamiento de argumentos del script -----------------------------------Los argumentos en la llamada al script sobre el indicativo del sistema, son considerados como variables especiales en el interior del guión. Los argumentos se referencian así: - $0: Nombre del script - $1, $2, ..., $8 y $9: Primer, segundo, ... , octavo y noveno argumento Escribir el número encerrado entre llaves: ${nn} para los argumentos siguientes. Por ejemplo, contenido y ejec ución del fichero “scrpt5_arg”: #! /bin/sh #script para el manejo de argumentos echo $0 $1 $2 $3 $4 $5 $6 $7 $8 $9 ${10}

#./scrpt5_arg 1 2 3 4 5 6 7 8 9 0 ./scrpt5_arg 1 2 3 4 5 6 7 8 9 0 # _ El comando 'shift' desplaza argumentos, es decir, si inicialmente el argumento 1 corresponde a $1, el 2 a $2 y el 3 a $3, después de llamar a ‘shift’ el contenido de las variables valdría: $1 nulo, $2= argumento 1 y $2 =argumento 2. Por ejemplo, contenido y ejecución del fichero “scrpt6_arg2”: #! /bin/sh #script para el manejo del comando shift con argumentos echo $1 $2 $3 shift echo $1 $2 $3 #./scrpt6_arg2 a b c a b c b c # _ Esta utilidad facilita el procesado de todos los argumentos en un bucle, usando una única variable encargada de r eferenciar desde el primer argumento hasta el último. Existen tres variables especiales asociadas al script y sus argumentos: - $#: Guarda el número de argumentos - $@: Lista todos los argumentos separados por espacios - $$: Almacena el PID (identifi cador de proceso durante su ejecución)

49

Por ejemplo, contenido y ejecución del fichero “scrpt7_arg3”: #! /bin/sh ps echo $# echo $@ echo $$ #script para presenta el valor de $#, $@ y $$

#./scrpt7_arg3 a b c ... 89 tty1 root 624 ... 3 a b c 89 # _ Comandos de sustitución -----------------------

S

/bin/sh ./scrpt7_arg3 a b c

Un comando de sustitución genera la respuesta de un mandato en el sitio ocupado por su nombre dentro del script, es decir, primero el comando se llama en el script y posteriormente el resultado obtenido sustituye al comando en tiempo de ejecución. Hay dos formas de expresar un comando de sustitución: A) $(nombre_comando) B) `nombre_comando`

(el signo "`" es el acento reflejado derecha de la letra "p" -)

-a la

Por ejemplo el contenido y ejecución del fichero “scrpt8” sería: #! /bin/sh echo La fecha y hora del sistema es: $(date) echo La fecha y hora del sistema es: `date` #./scrpt8 La fecha y hora del sistema es: Fri Oct 29 18:40:17 UTC 2004 La fecha y hora del sistema es: Fri Oct 29 18:40:17 UTC 2004 # _ Expansión Aritmética -------------------El resultado de una expresión aritmética sustituirá a esta durante el procesado de un script. Su sintaxis es: $((expresión)) Los operadores son: + * / suma resta multiplicación división

Sólo puede trabajar con valores enteros. Por ejemplo, contenido y ejecución del fichero “scrpt9”: #! /bin/sh

50

echo $((3 * 4 / 6 + 1 - 3))

#./scrpt9 0 # _ Funciones --------Una función de script, i gual que en otros lenguajes de programación, representa un método donde agrupar un conjunto de sentencias bajo un nombre, el nombre de la función. Cuando aparece este nombre en el guión, el intérprete ejecuta automáticamente las órdenes asociadas. Equivaldría a un pequeño guión (admite incluso parámetros) dentro de un guión principal. La forma de escribir una función es: ...dentro del script... nombre_de_función() { Sentencia1; Sentencia2; ... SentenciaN; } Un script con funciones (y sus resultado en pantalla) sería: Ejemplo1: “script10_fun1” #! /bin/sh datos() { echo "usuario actual:" $(whoami) ; echo "fecha y hora:" $(date) ; } linea() { echo "--------------------------- " ; } doble_linea() { echo"================== ==========" ; } texto() { echo $@ ; } datos linea texto saludos desde microLINUX texto texto fin del mensaje. doble_linea #--- fin del script --#./script10_fun1 usuario actual: root

51

fecha y hora: Sat Oct 30 18:09:17 UTC 2004 ------------------------------saludos desde microLINUX fin del mensaje. =============================== # _ T A R E A S ----------1º Editar y ejecutar todos los scripts mostrados como ejemplo en la actividad. 2º Crear un script llamado “encuentra.s h” que busque en el árbol de directorios el fichero cuyo nombre es pasado como parámetro. 3º Realizar un script que convierta a segundos una cantidad cualquier expresada en horas. 4º Hacer un guión encargado de calcular la media aritmética de cinco valores enteros cualesquiera y posteriormente presente por pantalla dichos valores y el resultado de la media. Nota: variar la prioridad de las operaciones usando paréntesis. 5º Crear un script con funciones para ver tanto la pertenencia a usuario y a grupo de los ficheros de un directorio señalado por el usuario, como la fecha y hora del sistema y también el contenido del propio fichero. <->

52

Actividad 15: Scripts III. Estructuras de control. Introducción -----------Como cualquier lenguaje de progra mación, un script es capaz de decidir las acciones a tomar según el resultado de operaciones anteriores. También ofrece la posibilidad de repetir órdenes, ya sea un número fijo de veces, o hasta el cumplimiento de alguna condición. Estados de salida ----------------Puesto que la función principal del intérprete de comandos es llamar a otros programas, resulta natural desear controlar la secuencia de ejecución dentro de un script conforme al estado de salida de procesos anteriores. Para lograr esto, cada programa al finalizar devuelve un código al sistema señalando si acabó de forma exitosa (cero) o si existió algún error (número distinto de 0). Siempre que el shell necesita tomar una decisión basada en el resultado de otros programas, considera como 'c ierto' a un valor 0 y como 'falso' a cualquier otro. El valor del estado de salida de una orden se obtiene con $?: #comando_a_ejecutar_y_sus_parámetros #echo $? --- ('0' verdadero y '1' falso) --Operadores ---------los operadores son los enca rgado de determinar si llevar a cabo una sentencia o conjunto de sentencias asociadas. Tal decisión acaba expresándose como un valor binario, es decir, 'cierto' o 'falso'. Pueden agruparse según el tipo de operador: Operadores Booleanos && || ! <-- Equivale a una "AND" lógica. Acción1 Y Acción2 <-- Equivale a una "OR" lógica. Acción1 O Acción 2 <-- Equivale a una "NOT" lógica. Cambiar Resultado Acción

Operadores de test (ó "[") + Test de ficheros -d nombre_de_directorio <- verdadero si es dire ctorio -f nombre_de_fichero <- verdadero si es fichero -L nombre_de_enlace_simbólico <- verdadero si es enlace simbólico -x nombre_de_fich_ejecutable <- verdadero si es ejecutable -s nombre_de_fichero <- verdadero si existe y con datos fich1 -nt fich2 <- verdadero si fich1 es más reciente que fich2 fich1 -ot fich2 <- verdadero si fich1 es más antiguo que fich2 + Test de cadenas cadena1 = cadena2 cadena1 != cadena2 -z cadena + Test numérico n1 -eq n2 <- verdadero si cadena1 es igual a cadena2 <- verdadero si cadena2 es distinta a cadena2 <- verdadero si cadena tiene longitud cero

<- verdadero si n1 y n2 son iguales

53

n1 n1 n1 n1 n1

-ne -gt -ge -lt -le

n2 n2 n2 n2 n2

<<<<<-

verdadero verdadero verdadero verdadero verdadero

si si si si si

n1 n1 n1 n1 n1

y n2 son es mayor es mayor es menor es menor

distintos que n2 o igual que n2 que n2 o igual que n2

+ Combinando o negando test test1 -a test2 test1 -o test2 !test <- verdadero si el test1 y el test2 son ciertos <- verdadero si el test1 o el test2 son ciertos <- valor negado del test

Es posible ver el resultado de la aplicación de los operadores, igual que en el apartado anterior con "echo $?". Los operadores booleanos pueden combinar los resultados de vari as pruebas. En particular, '&&' y '||' evalúan sus argumentos de izquierda a derecha, deteniéndose cuando se sabe el resultado total. Esto ayuda a efectuar combinaciones de control sencillas. El operador '!' invierte el sentido del valor de retorno de un p rograma. Estos operadores encadenan comandos, en particular aquellos en los que interesa conocer el estado de retorno de un programa. Por ejemplo: #com_A && com_B #com_B || com_B #!comando Ejecutará el com_B si el com_A terminó correctamente. Concatena la ejecución de com_A y com_B siempre. Si comando entrega tras su ejecución verdadero con esta orden dicho valor es el contrario.

El comando interno 'test' evalúa un expresión booleana simple formada por cadenas y números, entregando como valo r de retorno el resultado de la aplicación del operador correspondiente. '0' verdadero y '1' falso. Por ejemplo: #test 10 -lt 5 #echo $? 1 # _ #test -z "" #echo $? 0 # _ <-- ¿10 es menor que 5? <-- presenta resultado <-- falso

<-- ¿Es una cadena de 0 carac teres? <-- presenta resultado <-- verdadero

El comando 'test' tiene una representación alternativa con "[" útil en sentencias condicionales y bucles. Con este atajo debe incluirse "]" al final del argumento para señalar el límite de la expresión booleana. Estas consultas equivalen a las anteriores: #[ 10 -lt 5 ] #echo $? 1 # _ #[ -z "" ] #echo $? 0 # _ <-- Recuerda: hay que respetar los espacios en blanco para considerar la sintaxis correcta.

54

También existen los comandos internos 'true' y 'false' cuya función consiste simplemente en entregar al sistema el código de terminación '0' en el primer caso y '1' en el segundo: #true #echo #? 0 # _ #false #echo #? 1 # _ Estructuras de control ---------------------Hasta ahora es lógico pensar que un script ejecuta siempre el conjunto de sus tareas de forma secuencial puesto que son lanzadas una detrás de otra todas las acciones que almacena. Sin embargo existen herramientas cuyo propósito es romper esta linealidad y definen un orden diferente de ejecución. Estas herramientas pueden encontrarse en cualquier lenguaje de programación de alto nivel y son denominadas genéricamente "estructuras de control" porque representan un patrón de ejecución para un subconjunto de acciones. Las estructuras de control en un script son: - Estructura secuencial : Ya conocida, basada en el lanzamiento de una tarea tras otra. - Estructura condicional : Un grupo acciones se ejecutará si se cumple una condición. - Estructura iterativa: Permite repetir una o varias órdenes según un determinado criterio. Estructuras condicionales ------------------------Las estructuras condicionales son las encargadas de decidir si se realiza una acción o no; esta decisión se toma evaluando una e xpresión. Hay 4 variantes de estructura condicional: - condicional simple: si (expresión) entonces (órdenes) - condicional doble: si (expr) entonces (órds_si) sino ( órds_no) - condicional múltiple : si (Ex_A) entonces (Or_A) sino si (Ex_B) entonces (Or_B)... sino si Ex_x) entonces (Or_x) - selección de tarea según condición: según (expresión) en caso A (órdenesA) en caso B (órdenesB)... en caso X (órdenesX) Donde "Órdenes" son acciones que el intérprete de comandos efectuará siempre que "Expresión" entregue como resultado un valor "verdadero". Una variante de la condicional múltiple es la selección de tareas según condición, donde se apuntan las tareas a ejecutar en función del valor de una expresión no booleana.

55

A continuación se muestr a la sintaxis aceptada por el intérprete acompañada de un ejemplo: Condicional simple: if [ expresión ]; then código_si_expresión_verdad fi Ejemplo "sc_if1.sh", necesita dos parámetros en la llamada: #! /bin/sh if [ $1 -eq $2 ]; then echo los parAmetros son iguales fi echo fin Condicional doble: if [ expresión ]; then código_si_expresión_verdad else código_si_expresión_falso fi Ejemplo "sc_if2.sh", necesita dos parámetros en la llamada: #! /bin/sh if [ $1 -eq $2 ]; then echo los parAmetros son iguales echo valor $1 else echo los parAmetros son distintos echo primer parAmetro: $1 echo segundo parAmetro: $2 fi Condicional múltiple: if [ expresión1 ]; then código_si_expresión1_verdad elif [expresión2 ]; then código_si_expresión2_verdad ... elif [expresiónN ] ; then código_si_expresiónN_verdad else # código_si_expresiones1..N_falso # opcional fi Ejemplo "sc_if3.sh", necesita dos parámetros en la llamada: #! /bin/sh if[ $1 -eq $2 ]; then

56

echo los parAmetros son iguales echo valor: $1 elif[ $1 -gt $2]; then echo el primer parAmetro es mayor que el segundo echo valor: $1 elif[ $1 -lt $2 ]; then echo el segundo parAmetro es mayor que el primero echo valor: $2 fi Selección según condición: case _cadena_ in expresión1) código_si_cadena_igual_a_expresión1 ;; expresión2) código_si_cadena_igual_a_expresión2 ;; ... expresiónN) código_si_cadena_igual_a_expresiónN ;; *) código_cuando_cadena_tiene_otros_valores esac Ejemplo "sc_if4.sh" sin parámetros: #! /bin/sh echo pulsa una tecla por favor... read tecla # Pide al usuario un valor que guardará en "tecla" case $tecla in # toma el contenido de la varible "tecla" [aeiou]) echo ha pulsado una vocal ;; [bcdfghjklmnñpqrtvwxyz]) # vale cualquiera de estos caracteres echo ha pulsado una consonante ;; [A-Z]) # rango de caracteres desde 'A' hasta 'Z'. echo ha pulsado una letra mayUscula ;; [0-9]) echo ha pulsado un nUmero ;; *) echo ha pulsado algo distinto a letra O nUmero ;; esac Estructuras iterativas ---------------------Además de poder elegir entre varias opciones, el shell nos permite repetir una secuencia de mandatos un cierto número de veces, ya sea fijo o determinado por el cumplimiento de una condición en base a una expresión booleana. Hay 3 fórmulas de repetición distintas: - Bucle repetir_ HASTA_cumplir_condición ("until"): repetir (órdenes)

57

hasta (expresión) - Bucle repetir_ MIENTRAS _se_cumpla_condición ("whi le"): mientras (expresión) repetir - Bucle repetir_ PARA_un_rango_de_valores ("for"): para (expresión según rango) hacer (órdenes) A continuación se muestra la sintaxis aceptada por el intérprete acompañada de un ejemplo: Bucle hasta: until [ expresión ]; do código_a_iterar modificar_miembro_de_expresión done Ejemplo "sc_until.sh" sin parámetros: #! /bin/sh CONTADOR = 20 until [ $CONTADOR -lt 10 ]; do echo CONTADOR $CONTADOR let CONTADOR=$CONTADOR -1 # let es comando interno del intér prete. done Bucle mientras: while [ expresión ]; do código_a_iterar modificar_miembro_de_expresión done Ejemplo "sc_while.sh" sin parámetros: #! /bin/sh CONTADOR=0 while [ $CONTADOR -lt 10 ]; do echo el contador vale $CONTADOR let CONTADOR=CONTADOR+1 done Bucle para: for VARIABLE in [orden_shell ó lista de elementos]; do código_a_iterar done Ejemplo 1 "sc_for1.sh" sin parámetros: #! /bin/sh for i in $( ls ) ; do echo item: $i done Ejemplo 2 "sc_for2.sh" sin parámetr os:

58

#! /bin/sh for i in 1 2 3 4 5; do echo $i done T A R E A S ----------1º Editar los scripts de ejemplo y ejecutarlos para ver el resultado por pantalla. 2º Crear un script que tomando 2 parámetros numéricos determine el parámetro de mayor valor y lo presente por pantalla. 3º Mejorar el script de la actividad anterior para que calcule la media aritmética del valor numérico de un número indeterminado de parámetros. (Ayuda: utiliza el comando 'shift') 4º Generar la tabla de multiplicar del 2, 3, 4 y 5 con un script. (Ayuda: utiliza un for dentro de otro -for anidado-). <->

59

(En blanco)

60

Actividad 16: Información del kernel I. Datos suministrados durante el inicio del sistema. El KERNEL --------Tal y como se apuntó en la actividad 5 , durante el proceso de carga del sistema operativo, uno de los primeros eventos es la ejecución y carga en la memoria RAM del KERNEL del sistema. El núcleo (KERNEL) forma el centro del S.O., es el programa que controla la comunicación entre el usuario y la máquina, planifica las tareas a realizar, gestiona la memoria de todos los programas y procesos y muchos otros aspectos de funcionamiento de un ordenador. El núcleo no es un proceso separado del resto del sistema. Hay que imaginarlo como un conjunt o de rutinas (fragmentos de código ejecutable), constantemente en memoria al que accede cada proceso. El núcleo de microLINUX se conoce como un núcleo monolítico. Los controladores de dispositivos forman parte del mismo. Aunque se pueden cargar controladores de dispositivo (módulos) en memoria mediante la aplicación de comandos. Para aumentar la cantidad de memoria RAM disponible, el KERNEL puede emplear paginación de disco. Esto significa que cierta cantidad de memoria reside en disco (la llamada memor ia de intercambio o swap). Los ejecutables emplean bibliotecas compartidas de enlace dinámico, es decir, que los programas comparten el código de una única biblioteca localizada en un fichero del disco, permitiendo que los programas ocupen menos espacio, especialmente aquellos programas que emplean numerosas funciones de biblioteca. Esto supone, además, que sólo existe una copia de la biblioteca en memoria. Lo que reduce drásticamente la cantidad de memoria en uso. Datos del KERNEL ---------------Cuando el kernel se carga en memoria RAM una de sus tareas consiste en reconocer el hardware e iniciar los controladores de dispositivo que posee (definidos durante su compilación) informando al usuario de ello. En el caso de los controladores de dispositiv o muestra dos datos: [nombre del dispositivo empleado por el kernel]: [descripción] Por ejemplo: hdc: attached ide-cdrom driver Floppy driver(s): fd0 is 1.44 M Vemos que los controladores son identificados como fd0 ('f'lopy 'd'isk 0) y hdc ('h'ard 'd'isk C) respectivamente. Lectura de los datos del KERNEL ------------------------------Siempre que el usuario desee conocer esta información, puede manejar el comando 'dmesg'; Cada vez que sea llamado, presentará en pantalla toda la información generada durante el inicio del sistema. #dmesg Linux versión 2.4.25 (root@sobremesa1) (gcc versión 3.3.1 (SuSE linux))

61

# ... ... Puesto que la información es muy abundante, se recomienda presentarla por páginas: #dmesg | more (utilizar el tabulador para pasar de una página a otra)

O bien seleccionar aquellas líneas cuyo contenido nos puede interesar con el comando 'grep': #dmesg | grep cadena_a_encontrar Por ejemplo, si el usuario desea localizar la información del kernel relacionada con la uni dad de disquetes (fd0) escribiría en la consola: #dmesg | grep fd0 Floppy driver(s): fd0 is 1.44 M # _ Otros datos de interés ---------------------Otra fuente de información es el comando 'uname' encargado de aportar datos referentes a la versión y tipo de sistema operativo así como de la familia del procesador. Con "uname -a" obtendremos todos los datos posibles. #uname -a Linux (none) 2.4.25 # 9 sáb abr 24 11:38:08 CEST 2004 : 686 unknown # _ T A R E A S ----------1º Volcar por pantalla los datos del núcleo con 'dmesg'. 2º Filtrar la información anterior y extraer sólo la asociada a las unidades de almacenamiento masivo (hda, hdb, hdc, hdd ...). 3º Obtener la versión del kernel. 4º Visualizar las librerías compartidas de microLINU X almacenadas en "/lib" y su tamaño. <->

62

Actividad 17: Información del kernel II. Datos del sistema en tiempo de ejecución. (/proc). El directorio "/proc" --------------------El directorio "/proc" aparenta ser un directorio más. Cualquier usuario accede a él con el comando 'cd', vuelca el contenido con 'ls' o visualiza el interior del los ficheros con 'cat'. Sin embargo, ninguno de los ficheros de este directorio ocupa realmente espacio en disco. El núcleo captura todas las acciones hechas sobre "/p roc" y genera una respuesta al vuelo. En otras palabras, cuando es solicitado un listado de archivos con 'ls', el núcleo lo genera dinámicamente entregando el contenido deseado. Esto queda más claro usando algunos ejemplos. A continuación se muestra la lista de archivos y subdirectorios situados en "/proc". #ls /proc 1 2 3 30 31 32 363 4 # _

5 6 bus cmd cpuinfo devices dma drivers

execdomains filesystems fs ide interrupts iomem ioports irq

kcore kmesg ksyms loadarg locks meminfo misc modules

mounts net partitions pci self slabinfo stat swap

sys sysvipc tty uptime version

Los números representan directorios de cada proceso en ejecución del sistema. Por ejemplo la información sobre el proceso ID 363 es: #ls /proc/363 cmd environ cwd exe # _

fd maps

mem mounts

root stat

Estos archivos contienen diversos datos sobre el proceso. Por ejemplo, el fichero "cmdline" muestra la línea de comandos con la que el proceso se lanzó. El fichero "status" da información sobre el estado del proceso y "cwd" enlaza con el directorio de trabajo de ese proceso. Todos los datos relacionados con la memoria del sistema están guardados en el fichero "/proc/meminfo". Llamando al comando 'free' se verá que la información es la misma, sólo que los números se han reordenado. Este comando lo único que hace es leer en "/proc/meminfo" y colocar un poco la escritura en pantalla. La mayor parte de las herramientas con funciones de consulta asociada a los dispositivos conectados funcionan de esta manera. La información presente en "/proc" es útil a la hora de añadir un nuevo dispositivo. Por ejemplo, generalmente los elementos conectados al computador necesitan una serie de direcciones de entrada salida (E/S) para poder comunicarse con el pr ocesador central o con el sistema. Si dos dispositivos se encuentran configurados para utilizar las mismas direcciones de E/S nunca podrá conocerse en realidad quién llama o a quién se están pasando los datos, un auténtico desastre. Puede evitarse comproba ndo siempre cuáles son las direcciones en uso mirando en "/proc/ioports". El núcleo sólo nos presenta las direcciones de dispositivos que ha detectado y reconocido. En un sistema correctamente configurado, se deben presentar todos los dispositivos. Es posible aún conocer más información de "/proc" necesaria para nuevas configuraciones. Por ejemplo, "/proc/interrupts" lista los números de

63

interrupciones ocupadas (IRQ) y "/proc/dma" los canales de acceso directo a memoria (DMA) en uso. T A R E A S ----------1º Presentar el contenido del directorio "/proc". 2º Ejecutar una tarea en segundo plano, por ejemplo "#vi prueba &" y volver a listar el contenido de "/proc". 3º Buscar en el directorio del nuevo proceso en ejecución (corresponde a 'vi') los ficheros "cmdline" y "status" y volcar por pantalla su contenido. 4º Mostrar también en pantalla los puertos de E/S, las interrupciones y canales de DMA en uso. 5º Obtener la versión del kernel tomada de "/proc/version". <->

64

Actividad 18: Utilidades I. Comandos de información. Dentro de esta actividad aparece una recopilación de los comandos de uso más frecuente que pueden encontrarse en cualquier entorno LINUX. Están agrupados en los siguientes tipos: - Comandos de pantalla - Información de disco - Comandos estadísticos Comandos de pantalla -------------------MicroLINUX admite dos órdenes para refrescar los datos presentados en la consola: - 'clear' : Limpia la pantalla - 'reset' : Reinicia la pantalla A efectos prácticos ambos comandos tienen el mismo resultado, tras su ejecución el indicativo del sistema se sitúa en la primera línea de la pantalla. No requieren parámetros en su llamada. Comandos de información de disco -------------------------------Ofrecen información relacionada con ficheros, directorios, usuarios y procesos: -'df' : Indica el % de utilización de la unidad de almacenamiento. -'du' : Lista el tamaño en KBytes de cada directorio. -'basename' : Extrae el nombre de fichero de un "path" completo indicado como parámetro. -'dirname' : Igual que el anterior pero en lugar del nombre muestra el directorio. -'env' : Muestra las variables de entorno del intérprete de comandos y su contenido. -'pidof' : Permite obtener el identificador de un proceso del sistema. -'uniq' : Presenta por pantalla el contenido de un fichero excepto las líneas duplicadas. -'which' : Cuando es llamado con el nombre de un comando externo devuelve su localización en el sistema. Busca en los directorios señalados por la variable PATH. -‘xargs’ : Permite ejecutar un comando sobre cada uno de los items entregados en la entrada estándar. Ejemplos en el uso de estos comandos: #df Filesystem rootfs /dev/ram0 /dev/fd0 # _

1k-blocks 1793 1793 1412

Used 1352 1352 1271

Available 441 441 69

Use% 75% 75% 95%

Mounted on / / /mnt/disquete

Donde aparecen datos de cada sistema de ficheros: la capacidad total, su porcentaje de uso y el punto de montaje. #du /usr/local 109 /usr/local/bin 10 /usr/local/lib/tcc/include 21 /usr/local/lib/tcc

65

324 4 438 # _

/usr/local/lib /usr/local/include /usr/local

La columna de la izquierda representa el tamaño del directorio de su derecha. # basename /usr/local/lib/tcc/libtcc1.a libtcc1.a # _ # dirname /usr/local/lib/tcc/libtcc1.a /usr/local/lib/tcc # _ Manejados juntos 'basename' y 'dirname' ayudan a obtener respectivamente el nombre y directorio de un path (fichero y camino relativo o absoluto) entregado por el usuario. #env USER=root OLDPWD=/usr/local HOME=/ LOGNAME=root TERM=linux PATH=/usr/sbin:/bin:/usr/bin:/sbin SHELL=/bin/sh PWD=/home # _ Las variables listadas están disponibles desde el indicativo del sistema y también en el interior de cualquier script. Por ejemplo, al pedir el camino reconocido por el intérprete aparece en pantalla: #echo $PATH /usr/sbin:/bin:/usr/bin:/sbin # _ Comando ‘pidof’: #yes > /dev/null & <-Lanza en 2º plano a ‘yes’. Sin mensajes de pantalla #ps ... 55 tty1 root 592 R yes <-- 'ps' presenta 'yes' corriendo en ... segundo plano con el PID 55. #pidof yes <-- solicito el PID del proceso yes. 55 # _ #kill 55 #ps ... [2] 55 Terminated yes > /dev/null ... #_ La secuencia de acciones refleja un ejemplo típico en el uso del comando 'pidof', primero el usuario lanza una tarea en segundo plano, posteriormente solicita al sistema el identificador de proceso (#pidof nombre_de_proceso_en_ejecución) y con ese dato lo termina. #uniq nombre_fichero_texto

66

... muestra líneas contenidas en "nom bre_fichero_texto" eliminando aquellas que estén duplicadas ... # _ #which nombre_comando_interno_o_aplicación /camino/al/nombre/de/comando_interno_o_aplicación # _ #find / -name libtcc.a | xargs dirname /usr/local/lib # _ En este caso el parámetro que necesita el comando 'dirname' es redireccionado por 'xargs' para que lo tome del lugar donde depositó 'find' el resultado de su búsqueda. Comandos estadísticos --------------------Bajo este epígrafe se agrupan los comandos de microLINUX enca rgados de presentan resultados estadísticos de diferente naturaleza: - 'free' - 'time' - 'uptime' - 'wc' : Información de la cantidad de la memoria RAM y Swap (intercambio) del sistema. : Indica el tiempo de ejecución de un comando. : Informa del tiempo transc urrido desde el último arranque. : Programa que cuenta el número de líneas, palabras y bytes del fichero pasado como parámetro.

Ejemplos en el uso de estos comandos: #free Mem: Swap: Total: # _ total 6320 0 6320 used 3772 0 3772 free 2548 0 2548 shared 0 buffers 64

# time vi fichero_prueba ... Edición de fichero_prueba ... <Salida de vi> real 2M 15.56s user 0M 0.00s sys 0M 0.11s # _ Donde: - Real: representa el tiempo to tal de ejecución. - user: indica el tiempo que el procesador atiende un proceso de usuario. - sys: el tiempo de ejecución de una tarea propia del sistema. Por tanto el tiempo total es la suma de: T. modo usuario + T. modo sistema + T. Espera (tiempo de espera: tiempo durante el cual el procesador está ocioso o realiza otra tarea) # uptime 8:28pm

up 4 min, load average: 0.00,

0.00,

0,00

67

# _ Significado de esta información: - 8:28 pm : Hora actual. - up 4 min : Tiempo que microLINUX l leva activado desde el último arranque. - load average : Media de carga del sistema para tres períodos de tiempo: - 1 minuto - 5 minutos - 15 minutos La media de carga es la media aritmética de procesos preparados para correr en ese intervalo de tiempo (1 equivale a 100 % de carga). (nota: probar este comando con alguna tarea corriendo en 2º plano) # wc /etc/fstab 1 # _

6

30 /etc/fstab

El fichero "/etc/fstab" tiene 1 línea, 6 palabras delimitadas por espacios y un tamaño de 30 bytes. T A R E A S ----------1º Ejecutar los comandos vistos en la actividad y estudiar los resultado obtenidos. <->

68

Actividad 19: Utilidades II. Comandos de compresión y descompresión de ficheros. Introducción -----------Para poder instalar y actualizar programas en un sistema Unix y derivados, hay que familiarizarse con las herramientas de compresión y agrupación de archivos. Algunas, como 'tar' proceden de los primeros días. Mientras que otras, como 'gzip', son relati vamente modernas. El propósito de estas herramientas es empaquetar una serie de ficheros en un único archivo y comprimir este. Al comprimir el archivo, el tamaño del mismo se reduce, ganando espacio de disco. Lo normal es distribuir los programas en un s olo archivo de formato 'tar' y comprimido con 'gzip'. Para poder recuperar los datos originales debe conocerse las herramientas con que se hizo el empaquetado. Además de la distribución, estas utilidades sirven para crear copias de seguridad de datos. Compresor gzip y descompresor gunzip -----------------------------------Los programas 'gzip' y 'gunzip' son el compresor y descompresor desarrollados en el proyecto GNU. La función de 'gzip' consiste en tomar un fichero, comprimir sus datos, grabarlos en formato .gz y luego sustituir el fichero original con el comprimido. Esta sustitución se lleva a cabo si el archivo .gz se crea sin problemas. Así evita perder los datos si la compresión no tiene éxito. Es posible modificar bastante el comportamiento del programa con las opciones de línea de comandos. Suponer que hay un fichero llamado documento1.txt: #ls -l documento1.txt -rw-r--r-- 1 root # _

root

842 Oct 31 21:25 documento1.txt

Para comprimirlo con gzip escribir: #gzip documentos1.txt Esto sustituye el fichero documento1.txt con el archivo documento1.txt.gz: #ls -l documento1* -rw-r--r-- 1 root # _

root

37 Oct 31 21:27 documento1.txt.gz

Si se le pasa al compresor una lista de nombres, este los comprime creando un archivo para cada u no de ellos, cuyo nombre es el original más .gz. Observar que cada fichero original se comprime dando lugar a un archivo comprimido. Otros programas de tipo 'zip', especialmente para MS -DOS y algunos Unix, comprimen varios ficheros en un solo archivo. Es posible "ver" el contenido de un fichero de texto comprimido con 'gzip' utilizando una versión adaptada del comando 'cat' orientada a ficheros .gz, esta utilidad se llama 'zcat'. Por ejemplo: #echo hola > hola.txt #cat hola.txt hola #ls -l hola.txt

69

-rw-r--r-#

1

root

root

5 Oct 31 23:08 hola.txt

Si ahora es comprimido el fichero hola.txt se obtendrá hola.txt.gz: #gzip hola.txt Y para visualizar la información original se usará 'zcat': #zcat hola.txt.gz hola # _ El grado de compresión del fichero depende de su formato y contenido. Por ejemplo, muchos ficheros gráficos ya están comprimidos (como los GIF y JPEG), de manera que 'gzip' tiene muy poco efecto sobre ellos. Los ficheros con mayor tasa de compresión son los de texto plano y l os binarios ejecutables y de biblioteca. Para recuperar el fichero original a partir del comprimido usar 'gunzip' o también 'gzip -d'. #gunzip documento1.txt.gz #ls -l dococumento1* -rw-r--r-- 1 root root # _ Empaquetado de archivos ----------------------El programa 'tar' sirve para agrupar varios ficheros en unos solo, que será denominado genéricamente archivo (por archivar ficheros). El nombre significa archivo de cinta (Tape ARchive) ya que su uso original era hacer copias de respaldo de los ficheros sobre cintas magnéticas. Hoy en día el empleo de 'tar' no está restringido a las unidades de cinta. El formato del comando es: #tar función_y_opciones_de_tar ficheros Donde: - función: Es una única letr a que indica la operación a realizar. En microLINUX son: - c: crear. - x: extraer. - t: listar. - opciones: Es una lista de letras que indican diversos modificadores de función. en microLINUX son: - f: Nombre del fichero .tar (por defecto utiliza la entrada estándar). - O: Extrae a la salida estándar. - exclude: Fichero a excluir. - X: Fichero con nombre de archivo a excluir. - C: Cambia al directorio indicado antes de operar. - v: Muestra la lista de ficheros procesados. Para empaquetar todos los ficheros que comienzan con "sc_" puede llamarse al comando 'tar' de la siguiente forma: #tar cvf todos_sc.tar sc_*

842 Oct 31 21:36 documento1.txt

70

sc_for1 sc_for2 sc_for3 sc_if1 ... # _ Una vez creado el archivo .tar ya es posible distribuirlo. Para ex traer los ficheros, el comando es: #tar xvf todos_sc.tar sc_for1 sc_for2 sc_for3 sc_if1 ... # _ Si el que desempaqueta el archivo es el superusuario (root) entonces el propietario de los ficheros será el original. El comando 'tar' mantiene la r uta de cada fichero empaquetado relativa a la posición del archivo.tar cuando se creó. La extracción se hace relativa al directorio de trabajo actual. Antes de desempaquetar un archivo es recomendable echar un vistazo al contenido, para saber si se ha n incluido los directorios, o por el contrario hay que crearlos primero para evitar problemas en el desempaquetado. Visualizar el contenido del archivo .tar con: #tar tvf archivo.tar ... # _ En este momento no se ha realizado ninguna extracción, solo muestra el contenido. En el proceso de extracción, si el usuario no especifica ningún fichero son desempaquetados todos. Aunque es posible seleccionar el/los fichero/os a extraer individualmente. Para ello escribir el nombre completo incluida la ruta de acceso. Por ejemplo desempaquetar el fichero "sc_for2" almacenado en todos_sc.tar: #tar xvf todos_sc.tar sc_for2 sc_for2 # _ Uso conjunto de tar y gzip -------------------------Los archivos .tar no están comprimidos, son una manera de agrupar diversos ficheros en uno solo, pero sin comprimirlos. Lo habitual es combinar 'tar' y 'gzip' para obtener, de varios ficheros, uno solo comprimido. Una manera de hacer eficiente el manejo de los comandos de empaquetado y compresión consiste en utilizar la capacidad de concatenación del intérprete de comandos, de esta forma la compresión de un grupo de ficheros en un único archivo sería: #tar cvf - ficheros | gzip - > nombre_de_archivo.tar.gz

71

fich1 fich2 ... fichn # _ nota: el guión indica a las aplicaciones que la salida de cada comando es la salida estándar. Y para extraer los ficheros hay que hacer lo propio: #gunzip -c nombre_de_archivo.tar.gz | tar xvf fich1 fich2 ... fichn # _ T A R E A S ----------1º Crea el siguiente subárb ol de directorios y ficheros desde tu directorio hogar (como usuario normal): ../Agenda/lunes/programa_L.txt /martes/programa_M.txt /miércoles/programa_X.txt /jueves/programa_J.txt /viernes/programa_V.txt /fin_de_semana/programa_S.txt /programa_D.txt Donde en cada fichero programa_?.txt debe aparecer el siguiente texto: Programación día de la semana: El_día_que_corresponda hora 08:00 - 10:00 hora 10:00 - 15:00 hora 15:00 - 20:00 hora 20:00 - 23:00 Recordar:

2º Comprobar las utilidades de compresión (gzip), visualización (zcat) y descompresión (gunzip) con el fichero "../Agenda/lunes/programa_L.txt". Hacer una copia del fichero .gz llamada "copia_agenda.txt.gz". 3º Como usuario root descomprime el fichero "copia_agenda.txt.gz" y comprueba si se mantienen tanto el propietario como el grupo originales. 4º Empaquetar todo el subárbol en el fichero "agenda_semana.tar". 5º copiar el fichero anterior a un directorio difere nte. 6º Listar el contenido del fichero .tar. 7º Extraer el fichero "/Agenda/jueves/programa_J.txt". 8º Extraer todo el contenido del fichero .tar manejado en el apartado 6 y verificar si la estructura del subárbol sigue intacta. 9º Agrupar y comprimir todo el subárbol en un solo paso. 10º Realizar el proceso inverso al punto anterior también en un solo paso. <->

72

Actividad 20: Archivos especiales de dispositivos. Tipos y creación. Archivos de dispositivos -----------------------los archivos de dispositivos son un mecanismo de comunicación entre los elementos que forman parte del computador ("hardware periférico) y el sistema operativo. No son ficheros en sentido estricto, pero aparecen como ficheros desde el punto de vista de los programas. Es posible leer de ellos, escribir en ellos, etcétera. Cuando se accede a uno de estos ficheros, el núcleo reconoce la petición de entrada salida y la pasa a un controlador (driver) que realiza alguna operación, como leer datos del puerto serie o enviar da tos al dispositivo nulo. Los archivos de dispositivos suponen una vía de comunicación con los recursos del sistema, sin obligar a los programas a conocer cada detalle de funcionamiento de un aparato en concreto. En microLINUX los controladores se alojan en el mismo núcleo. Los ficheros de dispositivos aparecen en "/dev". Para cada dispositivo debe haber una entrada en "/dev". Por ejemplo, "/dev/ttyS0" corresponde al primer puerto serie, conocido como COM1 en MS -DOS. Pueden existir falsos dispositivos en "/dev" que no corresponden realmente a ningún elemento real. Por ejemplo "/del/null" actúa como un sumidero de octetos. Cualquier solicitud de escritura sobre "/dev/null" tendrá como consecuencia que los datos sean ignorados y no se genere ninguna señal de error. Al listar el contenido de "/dev" la pantalla presenta algo como esto: #ls -l /dev brw------- 1 root root 2, 0 Jun 2 11:00 fd0 ... crw-r----- 1 root root 4, 65 Jun 2 11:00 ttyS1 --------- ---------------- ------ -------------- ----^ ^ ^ ^ ^ ^ | | | | | | | | | | | + -- Nombre | | | | | | | | | + -- Fecha/hora de creación | | | | | | | + -- Nº mayor y menor del dispositivo | | | | | +-- nº de referencias al fichero y pertenencia a | | usuario y grupo | +-- Permisos del fichero | +-- tipo de dispositivo: b -> bloque (lee y escribe bloques de datos) y c -> carácter (lee y escribe bytes) Los permisos son importan tes en los dispositivos porque ayudan a limitar y controlar quién puede usar un cierto dispositivo y cómo. Por lo general hay ciertos dispositivos a los que es costumbre restringir el acceso. Especialmente en lo tocante a unidades de disco y particiones. Hay que asegurarse de establecer los permisos adecuados para los nuevos dispositivos creados.

73

Es posible tener enlaces simbólicos a ficheros de "/dev" para facilitar el acceso a ciertos dispositivos empleando más de un nombre. Al borrar un fichero e special no se retira el módulo controlador del núcleo. Así mismo, por añadir un archivo especial de dispositivo a "/dev" no se carga el módulo controlador del núcleo. Número mayor y menor de un dispositivo -------------------------------------Estos números identifican al dispositivo ante el Sistema Operativo cuando se realiza una petición de entrada / salida. El número mayor suele representar a un controlador del núcleo mientras que el menor especifica uno de los posibles dispositivos que maneja el con trolador. Cuando se realiza una petición de escritura o bien de lectura, el núcleo identifica el módulo que debe atenderle mediante el número mayor y con el número menor se elige el dispositivo concreto al que va dirigida la petición. Algunas veces el número menor se emplea para acceder a funciones concretas de un dispositivo. Añadir nuevos ficheros de dispositivos -------------------------------------Cuando en un sistema LINUX se actualiza el núcleo o se añaden nuevos controladores puede ser necesar io incluir un nuevo archivo especial de dispositivo mediante el comando 'mknod': # mknod -m permisos nombre tipo n_mayor n_menor Donde: -m permisos: Es un argumento opcional (por defecto rw) que establece los permisos del nuevo archivo. nombre: Es el nombre completo del fichero especial a crear, como "/dev/cdrom". tipo : Es 'c' para un dispositivo de caracteres o 'b' para uno por bloques. mayor: Es el número mayor del dispositivo. menor: Es el número menor de dispositivo. Para conocer los parámetros adecuados de los dispositivos a instalar, es conveniente saber los valores que admite el kernel. En la mayoría de distribuciones de LINUX la información se guarda en "/usr/src/linux/Documentation/devices.txt". Este fichero sólo existe si f ueron instalados los "fuentes" del kernel. Un ejemplo de dispositivos accesibles en microLINUX son los relacionados con las unidades de almacenamiento masivo: Nombre de dispositivo Tipo Mayor Menor ---------------------------------------------- ------ ------ ----- ----Unidades Enteras /dev/hda /dev/hdb /dev/hdc /dev/hdd (hda: (hdb: (hdc: (hdd: Hard Hard Hard Hard Disc Disc Disc Disc A) B) C) D) maestro esclavo maestro esclavo IDE0 IDE0 IDE1 IDE1 (o (o (o (o CD -ROM) CD -ROM) CD -ROM) CD -ROM) Bloque Bloque Bloque Bloque 3 3 22 22 0 64 0 64

74

Y cada una de sus particiones /dev/hda1 /dev/hda2 /dev/hda3 /dev/hda4 /dev/hdb1 /dev/hdb2 /dev/hdb3 /dev/hdb4 /dev/hdc1 /dev/hdc2 /dev/hdc3 /dev/hdc4 /dev/hdd1 /dev/hdd2 /dev/hdd3 /dev/hdd4 Partición1 Partición2 Partición3 Partición4 Partición1 Partición2 Partición3 Partición4 Partición1 Partición2 Partición3 Partición4 Partición1 Partición2 Partición3 Partición4 primaria primaria primaria primaria primaria primaria primaria primaria primaria primaria primaria primaria primaria pri maria primaria primaria de de de de de de de de de de de de de de de de la la la la la la la la la la la la la la la la unidad unidad unidad unidad unidad unidad unidad unidad unidad unida d unidad unidad unidad unidad unidad unidad hda hda hda hda hdb hdb hdb hdb hdc hdc hdc hdc hdd hdd hdd hdd Bloque Bloque Bloque Bloque Bloque Bloque Bloque Bloque Bloque Bloque Bloque Bloque Bloque Bloque Bloque Bloque 3 3 3 3 3 3 3 3 22 22 22 22 22 22 22 22 1 2 3 4 65 66 67 68 1 2 3 4 65 66 67 68

Si el usuario de microLINUX desea crea un fichero de dispositivo que "conecte" con el controlador del kernel, primero debe conocer cómo denominó al dispositivo cuando fue detectado durante el arranque. Por ejemplo con estas consultas: #dmesg #dmesg #dmesg #dmesg | | | | grep grep grep grep hda hdb hdc hdd

Si en la respuesta obtenida aparece algo como: hda: 6346368 sectors (3249 MB) w/256KiB Cache, CHS=787/128/63 hda: hda1 hda2 <----------------------------- Particiones reconocidas. Según este mensaje el kernel reconoce 2 particiones primarias en el disco duro maestro de IDE0 (las lógicas son mostradas entre paréntesis). Por lo tanto es posible crear los ficheros de dispositivos "/dev/hda1" y "/dev/hda2" para que microLINUX tenga capacidad de acceso a las particiones: #mknod /dev/hda1 b 3 1 #mknod /dev/hda2 b 3 2 Otra forma de obtener esta información es consultando el fichero "/proc/partitions" donde el kernel almacena una relación de las particiones del sistema, su tamaño y números mayor y menor: #cat /proc/partitions major minor #blocks 3 3 3 # _ T A R E A S ----------1º Ver las características de los ficheros de dispositivos instalados en 0 1 2

name

3173184 hda 253984 hda1 2919168 hda2

75

microLINUX con "ls -l /dev". 2º Localizar según los procedimientos explicad os en la actividad las particiones del disco duro que puede manejar el kernel. 3º Con los valores anteriores crear los ficheros de dispositivos asociados. <->

76

Actividad 21: Sistema de ficheros. Montaje, sincronización y desmontado. Introducción -----------Los sistemas de ficheros son la base de todos los datos en un sistema LINUX. Todos los programas, librerías, archivos del sistema y los archivos de usuario, residen en los sistemas de ficheros. Es fundamental administrar correctamente estos archi vos porque todos los datos y programas se encuentran en ellos. Los sistemas de ficheros se pueden localizar en discos duros, flexibles, CD-ROM y otros medios de almacenamiento con acceso aleatorio. La forma y disposición concreta en que el archivo se a lmacena en el medio no es importante por sí misma. El sistema proporciona una interfaz común para todos los tipos de sistemas reconocidos por el kernel. Cada sistema de ficheros tiene su propia forma de almacenar los datos, no obstante, LINUX nos los va a presentar en forma de árbol jerárquico de directorios. Junto con los ya conocidos mecanismos de permisos, propietarios, grupos, etcétera. De hecho la información de tipo de propietarios o permisos sólo la suministra los sistemas preparados para trabaja r con LINUX. En los demás, es el mismo LINUX quien finge esos datos. Por ejemplo, el sistema operativo MS DOS no tiene el concepto de propietario, por tanto, todos los archivos aparecen como propiedad de root. De esta manera todos los sistemas de ficheros presentan una apariencia similar y mantienen una serie de atributos comunes, independientemente de que en el sistema de ficheros físico que hay por debajo de estos atributos no tengan ningún significado. Tipos de sistemas de ficheros válidos para microLIN UX ----------------------------------------------------El kernel de microLINUX fue compilado para admitir los siguientes sistemas de ficheros: Sistema de ficheros Tipo Descripción -------------------------------------------------------------------- --------Sistema de ficheros extendido nº2 ext2 Sistema normal de LINUX Minix minix Sistema original del SO minix ROM romfs Pequeño sistema de sólo lectura empleado en discos RAM. VFAT vfat Acceso a los archivos pertenecientes a W95/ 98 /proc proc Proporciona información para su procesado por el comando ps. Aspecto de un sistema de archivos --------------------------------Bajo LINUX, el espacio de archivos que resulta visible para los usuarios se basa en una estructura en á rbol, con la raíz en la parte superior. Los distintos directorios y archivos se ramifican hacia abajo desde la raíz. El directorio superior "/" se conoce como directorio raíz. El primer nivel de jerarquía en el árbol de directorios de microLINUX es el siguiente: / bin/ dev/ <-- Directorio raíz. <-- Tiene programas ejecutables, conocidos como binarios. <-- Guarda los archivos de dispositivos.

77

etc/ home/ lib/ mnt/ proc/

Almacena los archivos de configuración. Desde aquí cuelgan los directorios personales de l os usuarios. Contiene librerías compartidas para la ejecución de programas. Lugar donde montar los sistemas de ficheros. Sistema de archivos virtual para leer información de los procesos en memoria. sbin/ <-- Encargado de los ejecutables del sistema. tmp/ <-- Almacena los archivos temporales. usr/ <-- contiene programas y datos de usuario.

<-<-<-<-<--

Montar desmontar y sincronizar un sistema de ficheros ----------------------------------------------------MONTAR Antes de acceder a un sistema de ficheros hay que montarlo en algún directorio. Esto hace que el contenido del sistema montado, aparezca por debajo del directorio en que se monta. Para montar un sistema hay que emplear, como root, el comando 'mount'. Los usuarios normales tienen permitido el manejo de 'mount' con ciertas limitaciones: solo pueden montar los dispositivos que estén listados en: /etc/fstab. La sintaxis del comando 'mount' es: #mount [-t tipo] dispositivo punto_de_montaje Donde: -t tipo: Tipo de sistema de ficheros (ver tabla anterior). dispositivo: Archivo especial que le corresponde (Ej. /dev/hda1). punto_de_montaje: Directorio bajo el cual debe aparecer. Por ejemplo, Si hay una partición "/dev/hda2" en formato “segundo sistema extendido” (ext2) y el usuario la quiere montar bajo el directorio "/mnt" utilizará: #mount -t ext2 /dev/hda2 /mnt En caso de no especificar el sistema de ficheros, el S.O. prueba los diferentes tipos aceptados por el núcleo (ver "/proc/filesystems"). Entrega ndo un mensaje de error si la orden no se completó satisfactoriamente. Pueden consultarse los dispositivos montados con 'mount' sin argumentos: #mount rootfs on / type rootfs(rw) /dev/ram0 on /type ext2 (rw) /dev/fd0 on /mnt/disquete type ext2 (rw) /proc on /proc # _ DESMONTAR Para desmontar emplear el comando 'umount' acompañado del punto de montaje a desinstalar o el dispositivo instalado: #umount /mnt <-- Desmonta el sistema de fichero que 'cuelga' de "/mnt" type proc (rw)

78

#umount /dev/fd0 ¡¡¡ PRECAUCIÓN !!!

<-- Desmonta el disquete

NUNCA RETIRE UN DISQUETE DE SU UNIDAD SIN HABERLO DESMONTADO ANTES Para poder desmontar una unidad es obligatorio que el indicativo del sistema esté situado fuera de cualquier directorio que pertenezc a al mismo, en caso contrario el sistema entrega un mensaje de error. SINCRONIZACIÓN Las lecturas y escrituras sobre discos flexibles se hacen, en realidad, sobre una zona de memoria llamada memoria intermedia (buffer). De esta manera el acceso al disco se optimiza. Así el Sistema Operativo realiza las operaciones de lectura y escritura de forma desincronizada con el trasvase de datos entre unidad y memoria. El comando 'sync' (sincronizar) obliga la escritura física en las unidades de almacenamiento. A l desmontar un disco, como es natural, se produce un vaciado de la memoria intermedia actualizando el sistema de ficheros. #sync <- sincroniza el disquete volcando el contenido del buffer a disco Montaje de sistemas de archivos durante el arranque --------------------------------------------------En la mayoría de los casos, los sistemas de archivos que utiliza un sistema LINUX no cambian. Por esta razón, es fácil especificar una lista de archivos que LINUX monta al arrancar y que desmonta cuando se a paga. Esos archivos aparecen en un archivo especial de configuración llamado "/etc/fstab", que significa 'tabla del sistema de archivos'. El archivo "/etc/fstab" enumera los sistemas de archivos que van a montarse, incluyendo un sistema de archivos por l ínea. Los campos de cada línea están separados por espacios o tabuladores. Un ejemplo de archivo "/etc/fstab" podría ser: #cat /etc/fstab proc /proc /var/hdc2 /home/windows98 T A R E A S ----------1º Consultar los sistemas de ficheros manejados por el S.O. con el comando mount. 2º Visualizar el fichero "/etc/fstab". 3º Con ayuda de los ficheros creados en la actividad anterior busca, si la tienes, la partición FAT de Windows 95 o Windows 98 que existe en tu disco duro. nota: Es recomendable usar el directorio "/var" para guardar en él los archivos de dispositivos que cree el usuario con el fin de no perder estos ficheros al reiniciar. 4º Crear el directorio "/mnt/windows" y montar sobre él la partición de Windows del disco duro. 5º Verificar el correcto montaje con 'mount'.

proc vfat

default default

0

0

79

6º Acceder al directorio "/mnt/windows" y comprobar la capacidad de microLINUX para desplazarse por el árbol montado, así como editar y crear ficheros. 7º Modificar el ficher o "/etc/fstab" con el fin de permitir arrancar microLINUX con capacidad de acceso a la partición Windows en el directorio "/home/windows" de forma (crear primero el directorio) inmediata. <->

80

Actividad 22: Introducción a la programación estructurada. Lenguaje C. Introducción -----------Un PROGRAMA es un conjunto de mandatos que puede someterse, como una unidad, a un ordenador y utilizarse para dirigir su comportamiento. Cada uno de los mandatos recibe el nombre de SENTENCIA o INSTRUCCIÓN. Todo programa está constituido por uno o varios algoritmos. Un ALGORITMO es sencillamente un conjunto de reglas para efectuar algún cálculo. La construcción de un algoritmo debe ser lo más independiente posible de los lenguajes de programación. Para llegar a la solución (algoritmo) que resuelve un problema, se debe pasar por varios niveles de abstracción. El nivel máximo ha de ser totalmente independiente de los lenguajes de programación; en cambio, el nivel menos abstracto ha de estar orientado al lenguaje de programación que se utilice. Programación estructurada ------------------------La programación estructurada es una técnica para diseñar programas basada en los siguientes principios: - Modularidad: Un programa puede construirse a partir de unidades lógicas, razonablemente pequeñas, que se denominan módulos (en lenguaje C, funciones). - Diseño Descendente: El diseño se hace de los general a lo particular, considerando que una determinada función está resuelta y dejando su construcción para un paso post erior. - Teoría de la estructura: Cualquier programa puede ser diseñado empleando sólo tres tipos de estructuras de control. - Secuencial.- conjunto de acciones ejecutadas una a continuación de otra una sola vez. - Condicional.- Permite ejecutar un grup o de acciones u otro, dependiendo de que se cumpla o no una condición. - Repetitiva.- Ejecuta una o varias acciones un número controlado de veces. Los programas así diseñados serán fáciles de verificar, depurar y mantener. Ciclo de vida de un programa o aplicación ----------------------------------------Diseñar un programa no se reduce sólo a escribir un determinado algoritmo en algún lenguaje de programación; esto sólo se corresponde dentro del ciclo de vida de un programa con la fase de codificac ión. La vida de un programa abarca desde el momento que se establece la definición del problema hasta que dicha aplicación es desechada. Las etapas en la vida de un programa son: Definición y enunciado. Diseño y análisis. Codificación. Comprobación y depuración.

81

- Documentación y mantenimiento. A continuación se describe cada una de ellas. DEFINICIÓN Y ENUNCIADO En esta fase debe definirse con claridad todo lo que atañe al problema que se quiere resolver. Esta definición incluirá una lista completa de todos los requisitos que se deben cumplir y se especificará la solución esperada tanto para los datos de entrada correctos como para los incorrectos. El programa ha de responder en todos los casos sin que se origine una finalización anormal del mismo. DISEÑO O ANÁLISIS Puede dividirse en alto y bajo nivel. El primero consiste en realizar el planteamiento de la solución. Un problema no se suele componer de una sola tarea, sino de varias relacionadas. Por ello, una solución debe especifi car las tareas que a llevar a cabo, las responsabilidades de cada una y la forma de relacionarse e intercalarse las distintas tareas. El diseño a bajo nivel consistirá en la selección de los algoritmos más apropiados y su representación en algún pseudocó digo (lenguaje próximo al materno), así como en la selección de las estructuras de datos más adecuadas. CODIFICACIÓN Hay que elegir el lenguaje de programación más adecuado al tipo de problema o a los algoritmos y estructuras de datos seleccionados en l a etapa de diseño. Independientemente del lenguaje escogido es conveniente utilizar un estilo de programación que sea fácilmente legible y pueda ser seguido por cualquier persona. El estilo más extendido se basa en la utilización de los sangrados de líneas (endentación). La codificación de los algoritmos debe presentar el mayor grado de eficiencia en cuanto a: Ejecución, código, memoria y Entrada/Salida. COMPROBACIÓN Y DEPURACIÓN No basta con escribir y ejecutar un programa correctamente según las especificaciones realizadas por los usuarios. Es necesario comprobar que los resultados son los adecuados en todos los casos, incluso en aquellos que no hayan sido comprobados explícitamente. Un modo de garantizar el buen funcionamiento del programa es la valida ción con respecto a sus especificaciones. La depuración de un programa consiste en detectar los casos más desfavorables que puede encontrar la aplicación, por ejemplo situaciones que abortarían la ejecución o bloquearían el ordenador (pulsación de un tec la indebida). La depuración también contempla la eliminación del código fuente redundante. DOCUMENTACIÓN Y MANTENIMIENTO La documentación de un programa es un proceso continuo a lo largo de todo el ciclo de vida. Cada etapa produce una documentación esp ecífica. Después de haber comprobado que el programa funciona correctamente, habrá que recopilar toda esta información producida a lo largo del proceso, completarla y organizarla para elaborar una documentación del programa que sea útil para sus usuarios y para los programadores encargados de su mantenimiento. Los programadores deben documentar el código producido por ellos. Esta última documentación consiste en colocar los comentarios que sean precisos entre las líneas de código.

82

Los programas no son e ntes estáticos, sino que deben ser revisados y actualizados constantemente porque se descubren nuevos errores, se modifica alguna especificación, se cambia de ordenador, etc. La fase en la cual se efectúan estas modificaciones posteriores se denomina mante nimiento. Una buena documentación facilita el mantenimiento de los programas de forma clara, sistemática y legible, la etapa de mantenimiento puede ser muy difícil, incluso imposible. Si se descubren errores en las fases anteriores, se tendrá que empezar de nuevo desde la etapa correspondiente. La fase de mantenimiento implicará, en muchos casos, repetir varias de las etapas anteriores, según se trate de cambios en la especificación, sustitución de un algoritmo por otro considerado mejor, etc. Lenguajes de programación ------------------------A la hora de describir al ordenador como resolver un problema, es necesario formalizarlo adecuadamente para que pueda entenderlo. Esta formalización se realiza a través de un lenguaje de programación. Se entiende por LENGUAJE DE PROGRAMACIÓN la notación para la descripción precisa de algoritmos o programas informáticos. Los lenguajes de programación definen de forma estricta la sintaxis y la semántica. Existen cinco generaciones de lenguajes de programación: PRIMERA GENERACIÓN Está formada por los siguientes lenguajes: binario, máquina, ensamblador y macroensamblador. El alfabeto del lenguaje binario es el 0 y el 1, es decir, cada instrucción se corresponde con una determinada configuración de ceros y unos. A partir del lenguaje máquina, las instrucciones (mandatos) se representan mediante identificadores que están compuestos de caracteres alfanuméricos; estos lenguajes necesitan de un traductor para transformar los programas al lenguaje binario. A estos leng uajes también se les llama lenguajes de bajo nivel. SEGUNDA GENERACIÓN La componen los siguientes lenguajes: FORTRAN, COBOL, ALGOL y BASIC. También llamados lenguajes de alto nivel y de programación clásica. Los lenguajes de esta generación se pueden di vidir en dos amplias categorías: científicos y de gestión. TERCERA GENERACIÓN Estos lenguajes (también denominados lenguajes de programación moderna o estructurada) están caracterizados por sus potentes posibilidades procedimentales y de estructuración de datos. Se pueden dividir en dos grupos: lenguajes de alto orden de propósito general y lenguajes especializados. El primer grupo está constituido por los lenguajes PL/1, PASCAL, MODULA 2, C y ADA. Todos ellos descendientes del ALGOL. Estos lenguajes se utilizan en la construcción de gran espectro de aplicaciones (ciencia e ingeniería, comerciales, programación de sistemas y otros). Los lenguajes especializados están caracterizados por su usual formulación sintáctica, que ha sido especialmente diseña da para una aplicación particular. Se suelen utilizar en el mundo de la ingeniería de software. Ejemplos de ellos pueden ser LISP, PROLOG, APL, FORTH, etc.

83

CUARTA GENERACIÓN El nivel de abstracción va creciendo desde la primera a la tercera generación. Los lenguajes de cuarta generación incrementan, aún más el nivel de abstracción. El control y las estructuras de datos poseen una sintaxis distinta a la de anteriores generaciones con el fin de elevar el nivel de abstracción. Se pueden clasificar en dos grandes categorías: lenguajes de petición y generación de programas. Los primeros se han desarrollado para ser utilizados conjuntamente con aplicaciones de bases de datos. Los segundos, permiten al usuario crear programas en un lenguaje de tercera generaci ón usando notablemente menos sentencias.

QUINTA GENERACIÓN Varios procesadores modernos no soportan el ensamblador. Es decir son programados directamente en un lenguajes especializado de alto nivel como LISP código-P. Los lenguajes de quinta generación soportan el diseño orientado al objeto, el procesamiento paralelo y vectorial. Suelen ser de propósito particular. Son empleados en aplicaciones de investigación y de construcción de prototipos. Con la aparición del los sistemas operativos OS/2 y la serie Windows se han desarrollado programas que permiten la programación visual. Traductores y compiladores -------------------------Un programa codificado en lenguaje de alto nivel se pasa al lenguaje de la máquina a través del traductor correspondiente a ese lenguaje. Por lo tanto, un traductor es un programa que toma, como entrada, un programa escrito en un lenguaje (lenguaje fuente) y produce, como salida, un programa escrito en otro lenguaje (lenguaje objeto). Si el lenguaje fuente es de alto nivel ( como FORTRAN, BASIC o Pascal) y el lenguaje objeto es un lenguaje de bajo nivel (como ensamblador o lenguaje máquina), el traductor correspondiente se llama compilador. El compilador toma como entrada las instrucciones del lenguaje fuente y genera como sal ida instrucciones del lenguaje objeto; éste puede ser binario o máquina. El intérprete, a medida que traduce cada instrucción, la ejecuta sobre los datos que le corresponden (cero o más de un dato). Cuando ha terminado de ejecutar esa instrucción de alto nivel, repite el mismo proceso con la siguiente instrucción. De esa manera va avanzando hasta que se haya ejecutado todo el programa de alto nivel según los datos de partida. El intérprete es, en general, más pequeño que un compilador; pero el tiempo que tarda en traducir y ejecutar un programa fuente es más grande que el empleado por el compilador. Cuando se interpreta un bucle de instrucciones, éstas se traducen y ejecutan tantas veces como se repite el bucle. Si el lenguaje fuente es ensamblador y el lenguaje objeto es código de máquina, entonces el traductor se llama ensamblador. Si, por ejemplo, un compilador puede ejecutarse en un procesador (INTEL 80486) y producir código para otro procesador (MOTOROLA 68040), entonces se trata de un compilador cruzado. El lenguaje de programación C ----------------------------C es un lenguaje de programación de propósito general que ofrece como ventajas economía de expresión, control de flujo y un rico conjunto de operadores. Ha sido estrechamente asociado con el Sistema Operativo UNIX

84

puesto que tanto el propio S.O. como los programas que corren en él están escritos en C. Sin embargo, este lenguaje no está ligado a ningún S.O. ni a ninguna máquina. C a demostrado ser un lenguaje agradable, expresivo y ver sátil para una amplia variedad de programas. Es fácil de aprender y se obtienen mejores resultado a medida que aumenta la experiencia con él. Obtención de un programa en lenguaje C -------------------------------------Para la creación de un programa i nformático que pueda ejecutarse en el ordenador (binario), deben suceder varias etapas: - Generación del programa en código fuente (.c). - Compilación, obtención del módulo objeto (.o). - Linkado. Una vez concluido este proceso, el fichero generado p uede ser ejecutado por el PC de forma autónoma generalmente. GENERACIÓN DEL PROGRAMA EN CÓDIGO FUENTE El apartado A consiste en el diseño de un fichero de texto (obtenido a partir de un editor "ASCII", es decir, que no incorpore caracteres de control, por ejemplo el editor 'vi') que contendrá un número determinado de sentencias (instrucciones propias del lenguaje C): estructuras de control, órdenes de entrada y salida, etc. En un formato legible por el programador y que deben cumplir las reglas marcadas por el compilador (sintaxis, etc.). Una vez finalizado el fichero con extensión .c (regla no obligatoria pero si establecida convencionalmente por los programadores para señalar un fichero fuente escrito en lenguaje C) hay que proceder a su compilación. COMPILACIÓN Esto es, convertir el fichero para que sea comprensible al ordenador (módulo objeto). Generalmente el compilador realiza dos "pasadas" sobre el fichero de texto. En la primera buscará aquellas instrucciones dirigidas al propio compilador y que no pertenecen al lenguaje de programación en sí. La misión de estas pseudoinstrucciones (denominadas directivas o instrucciones del preprocesador) es la de realizar un tratamiento determinado sobre el contenido del fichero, por ejemplo la directiva: # include <------.h> Manda al preprocesador que la información del archivo que la acompaña (.h inicial de "header" representa un fichero cabecera que guarda información sobre las funciones contenidas en la biblioteca de C) sea incluida en el propio fichero fuente. LINKADO Durante la fase de reubicado o linkado el enlazador ("linker") recorre el módulo objeto y encuentra que falta las funciones de la biblioteca que se han declarado al compilador con la directiva correspondiente, y las añade, ya compiladas, adecuadamente en el lugar donde han sido llamadas. El enlazador es una herramienta que combina el programa de usuario con las funciones requeridas de la biblioteca. Dichas funciones son de formato reubicable. Esto significa que las funciones no defi nen las direcciones

85

absolutas de la memoria para las diversas instrucciones en código máquina, sino que mantienen la información de los desplazamientos relativos. Cuando se enlaza el programa con las funciones de la biblioteca estándar, el compilador usa los desplazamientos de la memoria para crear las direcciones reales usadas. <->

86

Actividad 23: Aplicaciones de usuario: Compiladores. Tcc (Tiny C Compiler). Introducción -----------TinyCC (también TCC) es un pequeño pero muy rápido compilador de C. T cc no solo soporta ANSI c, sino también el nuevo estándar ISO C99 y las extensiones GNUC incluyendo el ensamblador en línea. TCC puede ser usado para hacer scripts en C. Aunque TCC permite trabajar con las librerías estándar (stdio.h, stdlib.h, etcétera) la versión disponible en microLINUX requiere el uso de un único fichero de cabecera: <tcclib.h> que reúne las funciones estándar más comunes. En la distribución están incluidos un extenso grupo de programas escritos en C para demostrar la versatilidad de este compilador, además se acompañan, en forma de comentario de texto, los ficheros de cabecera .h necesarios para compilar estos fuentes en otros compiladores que admitan ANSI C. Invocación desde la línea de comandos --------------------------------- ---Para la llamada al compilador usar: # tcc [opciones] [fich_c_1 fich_c_2 ...] [ -run fich_c argumentos ...]

Donde las opciones más generales son: -v : Muestra la versión actual de TCC. -c : Genera un fichero objeto (también debe indicarse la o pción -o). -o nombre_fichero: Convierte el fichero objeto .o en ejecutable (binario) llamado "nombre_fichero". -r : Genera un fichero objeto combinando todos los ficheros de entrada. Ejemplos en el uso de Tcc: #tcc -c fich1.c <-- Compila fich1.c y ge nera el fichero objeto fich1.o

#tcc -o binario fich1.c <-- Compila fich1.c y genera el fichero ejecutable 'binario' #tcc -run fich.c #tcc -run fich.c arg1 <-- Compila fich.c y lo ejecuta directamente <-- Compila fich.c y lo ejecuta directa mente arg1 entrega el primer argumento a la función principal main() de fich.c

#tcc -o binario fic1.c fic2.c <-- Compila fic1.c y fic2.c, los enlaza y genera el ejecutable 'binario' #tcc -o binario fic1.o fic2.o <-- Enlaza juntos fic1.o y fic2.o y genera el ejecutable 'binario' #tcc -r -o fi.o fi1.c fi2.c <-- Compila fi1.c y fi2.c, los enlaza juntos y genera el fichero objeto fi.o

Recordar que para ejecutar cualquier binario deben cumplirse dos condiciones:

87

A) Poseer permisos de ejecución (si fuera necesario usar "chmod +x binario"). B) Llamar al fichero con la expresión "./nombre_del_ejecutable". Scripts en C -----------TCC puede ser invocado desde un script, de igual forma que un script de shell. Solo es necesario a ñadir la cadena "#! /usr/local/bin/tcc -run" para iniciar la ejecución del código C: Ver el siguiente ejemplo: #! /usr/local/bin/tcc -run #include <tcclib.h> int main() { printf("Hola desde microLINUX \n") ; return 0 ; } Tal y como se indica en el apartado anterior es necesario dar permisos de ejecución (chmod +x) y ser llamado usando el prefijo "./". T A R E A S ----------1º Editar y ejecutar el scritp C mostrado al final de la actividad. Nota: el fichero no "funcionará" si tiene extensi ón .sh. 2º Dirigirse al directorio "/usr/src" y desde allí buscar algún fichero fuente para compilar y ejecutarlo posteriormente. 3º Leer la información del compilador TCC ejecutando "#ayuda.sh tcc". <->

88