Sie sind auf Seite 1von 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)

Í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.

Actividad

1:

Acceso al sistema, ayuda en línea, cambio de sesión y cierre. Página 7.

Actividad 2:

La consola. Intérprete de comandos (shell), comandos internos (built-in), comandos externos y aplicaciones. Página 11.

Actividad 3:

Directorios de microLINUX. Creación, posición del usuario, cambio de ubicación, consulta de contenido y borrado de directorios. Página 13.

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. Página 17.

Actividad 5:

Proceso de arranque. Ficheros de configuración e inicio en microLINUX. Página 19.

Actividad 6:

Tratamiento de ficheros II. Edición de ficheros de texto con editor vi. Página 21.

Actividad 7:

Tratamiento de ficheros III. Enlaces fuerte y débil. Página 23.

Actividad 8:

Tratamiento de ficheros IV. Búsqueda, ordenación y extracción selectiva de datos. Página 25.

Actividad 9:

Gestión de usuarios. Creaci ón, propiedades y borrado de usuarios. Cambio de usuario. Página 29.

Actividad 10:

Concepto de grupo. Creación y borrado de grupos. Agregación

y

eliminación de usuarios a un grupo. Página 33.

Actividad 11:

Permisos en un sistema multiusuario. Página 37.

Actividad 12:

Procesos en LINUX. Estado de un proceso. Ejecución en primer

y

segundo plano. Página 41.

Actividad 13:

Scripts I. Ficheros de usuario ejecutados por el intérprete de comandos. Variables de entorno. Página 45.

Actividad 14:

Scripts II. Ampliación de comandos y Funciones. Página .

Actividad 15:

Scripts III. Estructuras de control. Página 53.

Actividad 16:

Información del kernel I. Datos suministrados durante el inicio del sistema. Página 61.

Actividad 17:

Información del kernel II. Datos del sistema en tiempo de ejecución. (/proc). Página 63.

Actividad 18:

Utilidades I. Comandos de información. Página 65.

3

Actividad 19:

Utilidades II. Comandos de compresión y descompresión de ficheros. Página 69.

Actividad 20:

Archivos especiales de disp ositivos. Tipos y creación. Página 73.

Actividad 21:

Sistema de ficheros. Montaje, sincronización y desmontado. Página 77.

Actividad 22:

Introducción a la programación estructurada. Lenguaje C. Página 81.

Actividad 23:

Aplicaciones de usuario: Compilado res. Tcc (Tiny C Compiler). Página 87.

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)

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.

I Ó N

-------------------

P

R

E

C

A

U

C

¡¡¡ 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 po r 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

bin: Directorio de binarios (ejecutables) del S.O

|

+-- dev

dev: Lugar donde se encuentran los archivos

|

descriptores de dispositivos.

|

+-- etc

etc: Contiene archivos de configuración del sistema.

| |

|

+--

init.d

|

+-- lib

 

lib: Almacena librerías (ficheros con código

|

|

ejecutable) compartidas por los binarios.

|

+--

teclado

|

+-- mnt

 

mnt: Espacio reservado para referenciar (montar y dar

|

|

accesibilidad) a las unidades de almacenamiento.

|

+--

disquete

|

|

|

+-- boot

|

|

|

+-- dev

|

|

|

+-- var

|

+-- home

 

home: A partir de aquí comienzan los dir ectorios

|

personales de cada usuario.

+-- proc

 

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

 

sbin: Almacena los ficher os binarios especiales del

|

sistema.

+-- tmp

 

tmp: Encargado de contener los archivos temporales.

|

+-- usr

 

usr: Reservado para aplicaciones de usuario (todos).

| |

| +-- bin

13

|

|

|

+-- sbin

 

|

|

|

+-- doc

 

|

|

|

+-- lib

 

|

|

|

+-- local

 

|

|

|

+-- bin

|

|

|

+-- include

|

|

|

+-- lib

|

|

|

+-- tcc

|

+-- var

 

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-).

¿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

#chdir /usr/local cambiar al directorio /usr/local

cambiar al directorio /etc

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

A R E A S

-----------

T

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 /

 

|

|

|

|

|

+ --

Chipset

|

+-- Disco_duro

|

|

|

+-- Lector_DVD

|

|

|

+-- RAM

|

|

|

+-- fuente_al

|

|

|

+-- Conectores

|

|

|

+-- Periféricos /

 

|

|

|

+ --

Pantalla

|

|

|

+ --

Teclado

|

|

|

+ -- Ratón

|

+-- Software /

|

+-- Sis_op

|

+-- Aplicaciones

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

<->

15

(En blanco)

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 Tipo -----

verde

---- Script (Archivo con órdenes orientadas al intérprete)

blanco

Archivo de texto

fucsia

Archivo especial asociado a dispositivo

azul claro Enlaces a directorios o archivos azul oscuro 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

install =/boot/bootsect

map

read-write backup =/dev/null image =/boot/KERNEL label =microLINUX

root

initrd =/micro_sf.gz

append

=/dev/df0

=/boot/map

=/dev/fd0

="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 --->

#!/bin/sh clear echo "+--------------------------------------------------------------------- +"

echo "|

echo "+------------------------------ --------------------------------------- +"

/mnt/disquete/var/etc/intro.sh

Bienvenido a microLINUX_VEM versión 1.0

|"

echo "|Para comenzar: [microLINUX] login: root [Intro] echo "| echo "|

|" + -------------------+"

echo "|

Más información con: ayuda.sh

|

|

| Ayuda de comandos |" |"

echo "|

--------

| #[comando] --help |"

echo "|

4)|

|" Acaba microLINUX |"

echo "|Hay cuatro consolas,usa [Alt]+[Fn] (donde n 1 echo "|Reinicia el intérprete de comandos con: # exit

echo "|Reinicia el sistema con: [Ctrl]+[Alt]+[Del]

|

|

# halt ó

|"

# 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

Acción

x

Borra el carácter bajo el cursor

dd

Borra la línea en la que se encuentra el cursor (todos los comandos en 'ayuda.sh')

i

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)

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

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 --> grupo clien /home/usuarios/dir_pro --> grupo prove

--> grupo usuarios

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)

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

Directorio

l

Enlace

-

Fichero normal

c

Fichero especial (tipo carácter)

b

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:

| u --> user (usuario)

Ámbito| g --> group (grupo)

| o --> others (otros)

| a --> all (todos)

| + --> Añade un permiso

Acción| - --> Elimina el permiso

| = --> Activa permisos absolutos ignorando los exi stentes

| r --> Permiso de lectura

| w --> Permiso de escritura/modificación

Tipo | x --> Permiso de ejecución (en directorios indica el acceso)

| s --> Permiso condicionado -nota 1-

| t --> Permiso condicionado -nota 2-

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:

#chmod ug+rwx fich_principal --> 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:

39

+--- Propietario

|

|

+--- Grupo

|

|

|

|

+--- Otros

|

|

|

v rwx rwx rwx 111 111 111 <-- Equivalente Binario ('1' permiso activo, '0' denegado)

v

v

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

Grupo

Permisos

-----------

-----

--------

/home/usuarios/ -->

usuario

usuario

drwxr-sr-x

cliente1

-->

cliente1

cli

drwxr-x---

cliente2

-->

cliente2

cli

drwxr-x---

proveedor1 -->

proveedor1

pro

drwxr-x---

proveedor2 -->

proveedor2

pro

drwxr-x---

proveedor3 -->

proveedor3

pro

drwxr-x---

dir_clien/ -->

usuario

cli

drwxrwxr-t

dir_prove/ -->

usuario

pro

drwxrwxr-t

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

TTY

Uid

Size State Command

1

root

620

S

init

2

root

0

S

[keventd]

3

root

0

S

[ksoftirqd_CPU0]

4

root

0

S

[kswapd]

5

root

0

S

[bdflush]

6

root

0

S

[kupdated]

30

tty1 root

620

S

-sh

31

tty2

root

496

S

/sbin/getty 38400 tty2

32

tty3

root

496

S

/sbin/getty 38400 tty3

22

tty1 root

612

T

vi

33

tty1 root

608

R

ps

#

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 --> Ejecución --> Fin

Ejemplo:

(R)

41

#date

Sun Oct 24 18:16:27 UTC 2004 <-- Ejecución

#_

<-- Llamada al proceso

<-- 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]

--+

Ejemplo:

(T)

#vi fichero_usuario pantalla del editor <Ctrl>+<Z> %1 Stopped

<-- Llamada al proceso <-- Ejecución <-- Parada del proceso

#

#bg

<-- Otros proceso <-- Activación del proceso detenido

pantalla del editor

<-- 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 <--

el programa "yes" lanza el mensaje por consola "y" en un bucle in finito (la

_

salida está redireccionada al dispositivo

<Ctrl>+<C>

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

<-- Pasa la tarea suspendida a primer plano.

#fg %2

<-- 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

#bg %2<-- Pasa la tarea 2 a ejecución en segundo plano (según 'jobs').

<-- Pone en ejecución en segundo plano la última tarea suspendida.

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 & <-- Lanza el editor "vi" en segundo plano.

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').

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 # _

#usar dobles comillas cuando hay espacios

#espera 3 segundos y continúa

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=" echo $mensaje3

sleep 3

$var_y

#espera 3 segundos y continúa

Al ser ejecutado aparece en pantalla:

#./scrpt3.sh

uno dos tres # _

Una última consideración. Es posible escrib ir caracteres inmediatamente después de una variable sin que el intérprete los asocie a ella. Esto es posible recurriendo al aislamiento del nombre de la variable con los símbolos de llave {nombre_variable}. Ver el contenido y ejecución del fichero

scrpt4.sh:

#! /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

echo $0 $1 $2 $3 $4 $5 $6 $7 $8 $9 ${10}

#script para el manejo de argumentos

#./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

#

b c

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

#script para presenta el valor de $#, $@ y $$

ps

echo $#

echo $@

echo $$

#./scrpt7_arg3 a b c

89

tty1 root

624

S

/bin/sh ./scrpt7_arg3 a b c

3

a

b c

89

#

 

_

Comandos de sustitución

-----------------------

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

-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 fich1 -nt fich2 fich1 -ot fich2

<- verdadero si es fichero

<- verdadero si existe y con datos <- verdadero si fich1 es más reciente que 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 -ne n2 n1 -gt n2 n1 -ge n2 n1 -lt n2 n1 -le n2

<- verdadero si n1 y n2 son distintos <- verdadero si n1 es mayor que n2 <- verdadero si n1 es mayor o igual que n2 <- verdadero si n1 es menor que n2 <- verdadero si n1 es menor 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 $?

<-- ¿10 es menor que 5? <-- presenta resultado

1

<-- falso

#

_

#test -z "" #echo $?

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

0

<-- 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 $?

<-- Recuerda: hay que respetar los espacios en blanco para considerar la sintaxis correcta.

1

#

_

 

#[ -z "" ] #echo $?

0

#

_

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 case $tecla in [aeiou])

# Pide al usuario un valor que guardará en "tecla"

# toma el contenido de la varible "tecla"

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)

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 5

execdomains kcore

mounts

sys

2 6

filesystems kmesg

net

sysvipc

3

bus

fs

ksyms

partitions tty

30

cmd

ide

loadarg

pci

uptime

31

cpuinfo

interrupts locks

self

version

32

devices

iomem

meminfo

slabinfo

363

dma

ioports

misc

stat

4

drivers

irq

modules

swap

#

_

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

fd

mem

root

cwd

exe

maps

mounts

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

-'env'

-'pidof'

-'uniq'

-'which'

-‘xargs’

directorio. : Muestra las variables de entorno del intérprete de comandos y su contenido. : Permite obtener el identificador de un proceso del sistema. : Presenta por pantalla el contenido de un fichero excepto las líneas duplicadas. : 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. : Permite ejecutar un comando sobre cada uno de los items entregados en la entrada estándar.

por la variable PATH. : Permite ejecutar un comando sobre cada uno de los items entregados
por la variable PATH. : Permite ejecutar un comando sobre cada uno de los items entregados
por la variable PATH. : Permite ejecutar un comando sobre cada uno de los items entregados