ERROR USUARIO NO VALIDADO

MÓDULO DE ARQUITECTURA E INTRODUCCIÓN AL S.O.

INTRODUCCIÓN

En este módulo vamos a revisar una serie de mandatos que nos van a permitir recuperar información sobre ciertas características del hardware de nuestra máquina. En concreto sobre las características del procesador, la memoria, discos, y periféricos. También se abordarán aspectos relacionados con el sistema de ficheros, creación de ejecutables y control de trabajos en el Shell.

Los mandatos internos del shell-bash utilizados en este módulo son los siguientes:

bg fg
jobs kill

Los mandatos externos (ejecutables) utilizados en este módulo son los siguientes:

cat df free gcc
hdparm less ls lsdev
ping ps sort stat
top tty vi vmstat

Del directorio etc se manejará el siguiente fichero:

  • /etc/services
  • /etc/fstab


Del directorio proc se manejarán los siguientes subdirectorios y ficheros:

  • /proc/<pid>/fd/
  • /proc/cpuinfo
  • /proc/dma
  • /proc/interrupts
  • /proc/ioports
  • /proc/irq
  • /proc/meminfo
  • /proc/mounts
  • /proc/scsi
  • /proc/sys


Se utilizarán los siguientes programas:

  • CPUyES.c
  • Identificadores.c
  • H2benchw.exe

EL DIRECTORIO PROC

El directorio /proc contiene un conjunto de ficheros especiales, que recogen información sobre el estado actual del sistema. Este conjunto de archivos permite tanto a usuarios como aplicaciones, conocer información detallada del hardware de nuestro sistema y del conjunto de procesos que se encuentran en ejecución en nuestro sistema. Este último aspecto, tiene como consecuencia, que el contenido del directorio /proc cambie de manera dinámica.

Por motivos de organización, los ficheros que contienen información sobre un mismo tema, se agrupan en directorios y subdirectorios. Además, un subdirectorio de un proceso en concreto, contendrá toda la información asociada a dicho proceso.

Hay que tener en cuenta ciertos aspectos relacionados con el directorio /proc:

  • Algunos de los ficheros solo son accesibles por el usuario root
  • Los ficheros contenidos en este directorio solo son accesibles en modo lectura.
  • Al listar el contenido del directorio, los ficheros pueden tener un tamaño de 0bytes, aunque cuando los visualicemos contengan una gran cantidad de información.
  • La información relacionada con la fecha y tiempo de creación, reflejan siempre el tiempo actual, puesto que dicha información se actualiza constantemente.

Los archivos especiales del directorio /proc/sys nos permiten ver y configurar ciertas opciones del kernel durante su ejecución. Sin embargo, las modificaciones que realicemos, no se conservarán después de reiniciar el sistema.

CARACTERÍSTICAS DEL PROCESADOR

Hasta hace poco tiempo, una de las características fundamentales de un procesador era la frecuencia de funcionamiento. En la actualidad, otros aspectos de importancia son el número de núcleos que posee, el tamaño de la memoria cache, etc. En una máquina con Sistema Operativo Linux, podemos extraer toda la información relativa al/los procesador/es del fichero /proc/cpuinfo. Cabe destacar que en máquinas multiprocesador, dispondremos de información independiente para cada una de las CPU.

Para acceder al contenido del fichero, podemos utilizar el mandato cat.




SOPORTE FÍSICO DE LA MEMORIA VIRTUAL

La memoria virtual está soportada por la memoria principal y por una parte del disco llamada de respaldo o swap.

Para conocer los valores de memoria de un sistema LINUX se puede utilizar el mandato free. El cual extrae su información del directorio /proc y en concreto del fichero meminfo.

Un ejemplo de ejecución del mandato free es:

alumno@maquinaLinux:~/$ free
             total       used       free     shared    buffers     cached
Mem:      16432176    2810428   13621748          0     241848    1865892
-/+ buffers/cache:     702688   15729488
Swap:      8191992        176    8191816

Ejecute el mandato free en su máquina y conteste a las siguientes preguntas.




ORGANIZACIÓN DE LOS DISCOS

Sobre un disco se construye uno o varios sistemas de ficheros.

A pesar de los avances en tecnológicos, el medio utilizado para el almacenamiento de información no ha cambiado considerablemente. Ha mejorado la velocidad de transferencia (gracias a la aparición de nuevos interfaces), la capacidad de almacenamiento ha aumentado y también ha disminuido el coste de almacenamiento.

Originalmente, las máquinas utilizaban dispositivos de almacenamiento IDE o SCSI, en la actualidad, los dispositivos SATA han sustituido a los IDE y se han convertido en una alternativa interesante frente a los SCSI. Linux además, proporciona soporte para el manejo de sistemas RAID (Redundant Array of Inexpensive Disks) y la administración de volúmenes lógicos (LVM - Logical Volume Management). No es propósito de estas practicas proporcionar información detallada sobre estos conceptos, pero se puede encontrar información adicional, por ejemplo en el capítulo 7 del libro: “La biblia de administración de sistemas Linux” (Editorial: ANAYA, Autor: Nemeth, Evi).

Nos centraremos en este apartado en conocer las herramientas que proporciona Linux para obtener información sobre los discos instalados en nuestra máquina.

Una primera aproximación, en máquinas de sobremesa o portátiles, consiste en utilizar el mandato df. Este mandato nos permite conocer el uso del espacio en los discos instalados en nuestra máquina. Por norma general, en Linux, los discos IDE, serán referenciados con el siguiente formato: /dev/hdX, donde X será una letra [a-z]. Por ejemplo, /dev/hda hace referencia al disco IDE primero y /dev/hdb disco IDE segundo. En el caso de tratarse de un disco SCSI o SATA, la nomenclatura será: /dev/sdX, donde X será una letra [a-z].

Si ejecutamos el mandato df.

alumno@maquinaLinux:~$ df
Filename  1K-blocks  Used     Available  Use %  Mounted on  
/dev/sda1  3845904   3545732  261100     94%   /  
tmpfs      647972    4        647968      1%   /dev/shm  
/dev/sdc1  24027628  20609812 3417816    86%   /home  
/dev/sdc2  11250644  929123   1959412    83%   /home/ftp  
/dev/sdb1  8751232   3541684  4765008    43%   /var  
/dev/sda6  473994    12310    661684      3%   /tmp  
/dev/sda7  2020060   807012   1213048    40%   /usr/local

En el ejemplo mostrado se observa que se dispone de tres unidades de disco SCSI/SATA:

El disco sda tiene tres particiones: la 1, 6 y 7, cada una de las cuales alberga un sistema de ficheros. Por su lado el disco sdb tiene una sola partición y el sdc tiene dos particiones, cada una de las cuales también tiene un sistema de ficheros.

Podemos encontrar información adicional sobre los dispositivos SCSI conectados a nuestra máquina accediendo al directorio /proc/scsi y más concretamente en el fichero scsi.

Podemos también utilizar el mandato mount o el fichero /proc/mounts o el fichero /etc/fstab, que proporcionan información sobre todos los sistemas de ficheros que están montados en el sistema en un momento dado.

Conteste las siguientes preguntas.





TABLA DIRECTORIO

Un directorio no es más que un fichero que contiene una tabla con los nombres de los ficheros y sus correspondientes identificadores físicos (número de nodo_i en Unix)

Para ver el contenido de un directorio se puede utilizar el mandato ls con la opción -i1. Si se añade la opción -a se muestran también los ficheros ocultos (que como sabemos son los que empiezan por el carácter «.»). De esta forma se lista simplemente la tabla directorio (nodo_i más nombre). Como hemos visto, el mandato ls proporciona, con otras opciones, más información sobre cada fichero, información que obtiene del nodo_i.

alumno@maquinaLinux:~$ls -ail 
220571  #pp#  
209799 . 
24680 .. 
220572 .Xauthority 
220573 .alias 
231785 .backup 
220574 .bash_history 
220575 .bash_logout 
220576 .bash_profile 
220577 .bashrc 
220578 .cshrc 
209800 .emacs.d 
220579 .lesshst 
220580 .projects.ede 
209802 .ssh 
71715  .viminfo 
220582 .zshrc 
231786 ProgrPrac 
231795 FicherosPrac

Cree un directorio llamado Prueba y ejecute el mandato ls –ai1.


TABLA DE DESCRIPTORES DE FICHERO

El sistema operativo mantiene por cada proceso una tabla con los descriptores de los ficheros abiertos por el mismo.

El directorio /proc también contiene información sobre procesos existentes en cada instante. En concreto, contiene un subdirectorio por cada proceso con el siguiente nombre /proc/<pid>, donde pid es el identificador del proceso (que se puede ver mediante el mandato ps). Entre la información contenida en este directorio, se encuentra la asociada a los ficheros que maneja el proceso. Cada vez que un proceso empieza a usar (abre) un fichero, a éste se le asigna un número entero no negativo denominado descriptor de fichero. Para acceder a los descriptores de fichero basta con listar el contenido del directorio /proc/<pid>/fd.
Los tres primeros descriptores de fichero están reservados para la entrada estándar (0), salida estándar (1) y salida estándar de errores (2). Estos descriptores están asignados por defecto al teclado y pantalla del terminal.

En la secuencia siguiente se han utilizado dos Shell. El primero sirve para crear un proceso y el segundo para visualizar la tabla de descriptores de fichero.

Shell 1: Ejecute el editor vi sobre un fichero que no exista previamente en el directorio en el que se está trabajando, por ejemplo: prueba_vi.txt

alumno@maquinaLinux:~$ vi PracticasAnalisis/ModuloArquitectura/prueba_vi.txt

Shell 2: Ejecute los mandatos ps –u <su_cuenta>, poniendo en vez de <su_cuenta> el nombre de su cuenta. Observe el PID del proceso vi y ejecute el mandato ls -l /proc/<PID>/fd/, poniendo en vez de <PID> el valor del pid del proceso vi.

alumno@maquinaLinux:~$ ps -u alumno
PID    TTY    TIME      CMD  
29638  ?      00:00:00  sshd  
29639  pta/1  00:00:00  bash  
29666  pta/0  00:00:00  vi 
29699  pta/1  00:00:00  ps  
 
alumno@maquinaLinux:~$ ls -l /proc/29666/fd/
total   4                     
lrwx------ 1 alumno GrupoAlumno 64 Jul 25 06:42 0 -> /dev/pts/0
lrwx------ 1 alumno GrupoAlumno 64 Jul 25 06:42 1 -> /dev/pts/0  
lrwx------ 1 alumno GrupoAlumno 64 Jul 25 06:40 2 -> /dev/pts/0  
lrwx------ 1 alumno GrupoAlumno 64 Jul 25 06:42 3 -> /home/alumnosSSOO/alumno/PracticasAnalisis/ModuloArquitectura/.prueba_vi.txt.swp

Cierre el editor vi.

En la secuencia anterior se ha utilizado el mandato ps con la opción –u que permite obtener todos los procesos de un usuario (si no se incluye dicha opción se obtienen solamente los procesos asociados al Shell desde el que se ejecuta el mandato). Del resultado producido por ls -l /proc/29666/fd/ se observará que la entrada estándar (número 0 de la tabla fd), la salida estándar (número 1 de la tabla fd) y la salida estándar de errores (número 2 de la tabla fd) están asignados al dispositivo /dev/pts/0 que no es más que la ventana ssh en la que se está ejecutando el proceso vi. Además, dicho proceso tiene abierto el fichero .prueba_vi.txt.swp (número 3 de la tabla fd). Es un fichero temporal que usa vi durante la sesión de edición. Cuando el usuario de vi ordene guardar el fichero, aparecerá el descriptor 4 asociado a prueba_vi.txt.

En el caso de que el fichero que abierto mediante el editor vi existiera previamente, podríamos comprobar que el descriptor 3 se asocia dicho fichero y el descriptor 4 se asocia a .fichero.swp.

Abra un fichero existente mediante el editor vi. Observe los descriptores de fichero presentes en su proceso vi y rellene los datos siguientes:




El mandato tty permite conocer el dispositivo asociado a la entrada estándar.

alumno@maquinaLinux:~$ tty
/dev/pts/0


REDIRECCIÓN

Los caracteres «<», «>» y « > > » se emplean en el Shell alfanumérico para redirigir la entrada y salida estándar de los mandatos.

Cada proceso abre tres “archivos” estándar (entrada estándar, salida estándar y salida de error). Estos ficheros son accesibles a través de unos descriptores de fichero, en concreto:

  • 0: Entrada estándar (normalmente el teclado).
  • 1: Salida estándar (normalmente la consola).
  • 2: Salida de error.

Para redirigir la salida estándar, utilizaremos el operador '>' o el operador '»'. La diferencia entre ambos consiste que en el primer caso, si el fichero al que se redirecciona la salida existe, su contenido se trunca (eliminamos su contenido y comenzamos a escribir desde el principio). En el segundo caso, si el fichero existe, el nuevo contenido se añade al ya existente.

Veamos cual es el funcionamiento mediante un ejemplo sencillo. En este ejercicio utilizaremos el mandato sort para redireccionar su salida y dos Shell. Como ya sabemos, este mandato muestra por su salida estándar lo que recibe por su entrada estándar de manera ordenada. Si no introducimos nada, sort se queda esperando, que es lo que ocurre en este ejemplo.

Shell 1: Ejecute el mandato sort.

alumno@maquinaLinux:~$  sort

Shell 2: Liste todos sus procesos (ps -u <usuario>) y a continuación liste los descriptores de fichero del proceso sort.

alumno@maquinaLinux:~$ ps -u alumno
PID   TTY    TIME      CMD  
8627  ?      00:00:00  sshd  
8628  pts/2  00:00:00  bash  
8643  ?      00:00:00  sshd  
8644  pts/3  00:00:00  bash  
8671  pts/2  00:00:00  sort  
8777  pts/3  00:00:00  ps  
 
alumno@maquinaLinux:~$ ls -l /proc/8671/fd/
total  3             
lrwx------  1  alumno  GrupoAlumno  64  Jul 25  12:41  0 -> /dev/pts/2 
lrwx------  1  alumno  GrupoAlumno  64  Jul 25  12:41  1 -> /dev/pts/2 
lrwx------  1  alumno  GrupoAlumno  64  Jul 25  12:40  2 -> /dev/pts/2

Observe que la entrada y salidas estándar están asignadas al dispositivo /dev/pts/2.

Shell 1: Mate el proceso sort (Ctrl+C) y vuelva a ejecutarlo, redireccionando su salida a un fichero, que puede existir o no. Si el fichero existe se borra su contenido (se trunca) y se llena con la salida del sort. Si no existe se crea.

alumno@maquinaLinux:~$ sort > Salida

Shell 2: Vuelva a listar los descriptores de fichero del proceso sort.

alumno@maquinaLinux:~$ ps -u alumno
PID   TTY    TIME      CMD  
8627  ?      00:00:00  sshd  
8628  pts/2  00:00:00  bash  
8643  ?      00:00:00  sshd  
8644  pts/3  00:00:00  bash  
8692  pts/2  00:00:00  sort  
8710  pts/3  00:00:00  ps  
 
alumno@maquinaLinux:~$ ls -l /proc/8692/fd/
total  3             
lrwx------  1  alumno  GrupoAlumno  64  Jul 25  12:41  0 -> /dev/pts/2 
l-wx------  2  alumno  GrupoAlumno  64  Jul 25  12:41  1 -> /home/alumnosSSOO/alumno/Salida 
lrwx------  3  alumno  GrupoAlumno  64  Jul 25  12:41  2 -> /dev/pts/

Observe que, ahora, el descriptor 1 (salida estándar) está asignado al fichero Salida.

En el caso del operador '<', este se utiliza para redirigir la entrada estándar. Es decir, el contenido del fichero especificado, se pasaría como parámetro al mandato.

Shell 1: Mate el proceso sort (Ctrl+C), y ejecute la siguiente secuencia de mandatos:

alumno@maquinaLinux:~$ ls -l /proc > listado_proc.txt

De este modo en el fichero listado_proc.txt tendremos un listado del contenido del directorio /proc.

Shell 1: A continuación redireccione la entrada del mandato sort con el fichero listado_proc.txt y la salida estándar al fichero ordenado_proc.txt.

alumno@maquinaLinux:~$ sort -r -k 8 < listado_proc.txt > ordenado_proc.txt


También podemos redirigir la salida de error estándar, para ello, deberemos especificar el descriptor de fichero a redirigir y a donde lo redirigimos. Por ejemplo:

alumno@maquinaLinux:~$ ls -l 2>error_ls.txt

De este modo, si se produce algún error durante la ejecución del mandato ls, dicho error se escribirá en el fichero error_ls.txt

TUBERÍA

La tubería o pipe permite comunicar dos procesos del mismo computador.

El carácter «|» se utiliza en el Shell para unir dos mandatos mediante una tubería. Para observar este hecho se plantea una secuencia que utiliza dos Shell. El primer Shell se utiliza para crear procesos y el segundo para observar los descriptores de fichero de los procesos.

Shell 1: Ejecute cat.

alumno@maquinaLinux:~$ cat

Shell 2: Obtenga los descriptores de fichero del proceso cat.

alumno@maquinaLinux:~$ ps -u alumno
 
PID   TTY     TIME      CMD  
9420   ?      00:00:00  sshd  
9421   pts/1  00:00:00  bash  
13034  pts/5  00:00:00  bash  
16327  pts/5  00:00:00  cat  
16329  pts/1  00:00:00  ps  
 
alumno@maquinaLinux:~$ls -l /proc/16327/fd/
 
total   3                 
lrwx------  1  alumno  GrupoAlumno  64  Jul  19  10:37  0 -> /dev/pts/5  
lrwx------  1  alumno  GrupoAlumno  64  Jul  19  10:37  1 -> /dev/pts/5  
lrwx------  1  alumno  GrupoAlumno  64  Jul  19  10:36  2 -> /dev/pts/5

En el ejemplo, observe que el proceso cat tiene tres descriptores de fichero abiertos correspondientes a las salidas y entrada estándar, todos ellos asociados al dispositivo /dev/pts/5.

Shell 1: Mate el proceso cat (Ctrl+C) y lance la ejecución de los dos mandatos cat y sort unidos por una tubería.

alumno@maquinaLinux:~$ cat | sort

Shell 2: Obtenga los descriptores de fichero de cat y sort.

alumno@maquinaLinux:~$ ps -u alumno
 
PID    TTY     TIME      CMD  
9420   ?       00:00:00  sshd  
9421   pts/1   00:00:00  bash  
13034  pts/5   00:00:00  bash  
16345  pts/5   00:00:00  cat  
16346  pts/5   00:00:00  sort  
16347  pts/1   00:00:00  ps  
 
alumno@maquinaLinux:~$ ls -l /proc/16345/fd/
 
total   3                 
lrwx------  1  alumno  GrupoAlumno  64  Jul  19  10:38  0 -> /dev/pts/5  
l-wx------  1  alumno  GrupoAlumno  64  Jul  19  10:38  1 -> pipe:[5637026]  
lrwx------  1  alumno  GrupoAlumno  64  Jul  19  10:38  2 -> /dev/pts/5  
 
alumno@maquinaLinux:~$ ls -l /proc/16346/fd/
 
total   3                 
l-wx------  1  alumno  GrupoAlumno  64  Jul  19  10:38  0 -> pipe:[5637026] 
lrwx------  1  alumno  GrupoAlumno  64  Jul  19  10:38  1 -> /dev/pts/5 
lrwx------  1  alumno  GrupoAlumno  64  Jul  19  10:38  2 -> /dev/pts/5

Shell 1: Para terminar pulse la combinación [Ctrl+c] con lo cual matará ambos procesos cat y sort.

En el ejemplo, observamos que el proceso cat tiene su descriptor 1 (salida estándar) asociado a una tubería de número 5637026. Por su lado, el proceso sort tiene asociada su entrada estándar (descriptor 0) a la misma tubería de número 5637026. Se dice que el Shell ha redirigido dichas salida y entrada estándar del terminal a la tubería.


PUERTOS DE COMUNICACIÓN

Los puertos sirven para comunicar procesos en máquinas remotas. Hay una serie de números identificadores de puerto que están asignados a determinados programas.

Cuando el fichero es muy grande, listarlo con el mandato cat no es conveniente. Para estos casos es más interesante utilizar el mandato less que presenta el fichero página a página y que permite navegar por él. Las funciones más importantes son las siguientes:

  • Moverse en el fichero línea a línea con las teclas «↓» y «↑» .
  • Moverse en el fichero página a página con las teclas de retroceso de página (Re Pág) y de avance de página (Av Pág).
  • Buscar una palabra con la tecla ”/” seguida de la palabra: /palabra_a_buscar
  • Buscar la siguiente ocurrencia con la tecla “n”, o la anterior con “N”
  • Salir mediante el carácter «q».

En el sistema UNIX, el fichero /etc/services contiene información de los números de puertos preasignados a programas servidores. Ejecutando el mandato less /etc/services se puede navegar por la lista de puertos preasignados.

Algunos de los valores producidos se muestran a continuación. La lista incluye el nombre del programa, el número de puerto y el tipo de puerto (udp o tcp), así como un posible comentario separado por «#».

tcpmux    1/tcp                # TCP port service multiplexer   
echo      7/tcp       
echo      7/udp       
discard   9/tcp sink   null   
discard   9/udp sink   null   
qotd     17/tcp quotee     
msp      18/tcp                #messafe send protocol 
msp      18/udp       
chargen  19/tcp ttytst source   
chargen  19/udp ttytst source   
ftp-data 20/tcp




ATRIBUTOS DE UN FICHERO

El servidor de ficheros mantiene para cada fichero información que permite identificarlo de manera única.

El mandato stat nos permite visualizar la información asociada a un fichero. Entre estas informaciones cabe destacar las siguientes:

  • Tamaño real del fichero, expresado en bytes (Size)
  • Espacio físico asignado al fichero, expresado en bloques, y tamaño del bloque
  • Tipo de fichero: directorio (directory) o normal (regular file)
  • Nodo_i que mantiene la información del fichero
  • Permisos de acceso
  • UID y GID del dueño del fichero
  • Instantes en los que fue accedido por última vez (Access), modificado el contenido del fichero (Modify) o modificado el contenido del nodo_i del fichero (Change)

Ejecute el mandato stat aplicado a un directorio y a un fichero normal.

alumno@maquinaLinux:~/PracticasAnalisis$ stat ModuloArquitectura
File: 'ModuloArquitectura/'
Size: 4096            Blocks: 8          IO Block: 4096   directory
Device: 821h/2081d      Inode: 1746662     Links: 2
Access: (0755/drwxr-xr-x)  Uid: ( 1001/ alumno)   Gid: ( 1000/GrupoAlumno)
Access: 2005-07-19 08:27:36.000000000 +0200
Modify: 2005-07-18 18:13:21.000000000 +0200
Change: 2005-07-18 18:13:21.000000000 +0200
 
alumno@maquinaLinux:~/PracticasAnalisis$ cd ModuloArquitectura/
 
alumno@maquinaLinux:~/PracticasAnalisis/ModuloArquitectura$ stat identificadores.c
File: 'identificadores.c'
Size: 286             Blocks: 8          IO Block: 4096   regular file
Device: 821h/2081d      Inode: 1746842     Links: 1
Access: (0644/-rw-r--r--)  Uid: ( 1001/ alumno)   Gid: ( 1000/GrupoAlumno)
Access: 2005-07-19 05:39:01.000000000 +0200
Modify: 2005-07-02 10:40:10.000000000 +0200
Change: 2005-07-18 15:34:54.000000000 +0200

Observe, en el ejemplo, que el fichero tiene un tamaño de 286 B pero ocupa en el disco 8 bloques. Para conocer el tamaño del bloque se puede usar el mandato stat con la opción de formato. En el ejemplo que sigue se obtienen los valores de %b, %B y %o, que son respectivamente el nº de bloques que tiene asignado el fichero, el tamaño de los bloques asignados y el tamaño del bloque de E/S, es decir, el tamaño mínimo de información que lee o escribe el sistema operativo cuando accede al fichero.

alumno@maquinaLinux:~/PracticasAnalisis/ModuloArquitectura$ stat identificadores.c --format='Nº bloques = "%b" Tamaño bloque = "%B" Tamaño E/S = "%o"'
Nº bloques = 8 Tamaño bloque = 512 Tamaño E/S = 4096

De los datos anteriores se observa que el tamaño físico del fichero es de 8•512 B = 4 KB, frente a los 286 B de tamaño real que tiene el fichero.

Ejecute el mandato stat sobre el fichero Identificadores.c y rellene los siguientes datos:




CONTROL DE TRABAJOS EN EL SHELL

Desde un shell alfanumérico se pueden lanzar trabajos en primer plano (foreground) y trabajos en segundo plano (background).

El modo normal de lanzar un trabajo es en primer plano. Como ya sabemos, esto se hace escribiendo el nombre del trabajo o mandato en la línea de mandatos. Para lanzar un trabajo en segundo plano basta con añadir al final de la línea de mandatos el carácter «&», dejando un espacio en blanco entre el mandato y «&». Los trabajos en segundo plano dejan libre el terminal para seguir ordenando mandatos al Shell. En cada sesión de shell puede haber varios trabajos en segundo plano, pero solo uno (o ninguno) en primer plano.

Ejecute en segundo plano el mandato vmstat 10 redirigiendo su salida a un fichero (se quedará ejecutando indefinidamente y más adelante lo terminaremos).

alumno@maquinaLinux:~$ vmstat 10 > estado &
[1] 27430



Observamos que el sistema nos responde con el PID = 27430 del proceso creado y con el número [1], para indicarnos que es el proceso en segundo plano nº 1.

Ejecute el mandato top. Este mandato presenta una tabla que monitoriza los procesos existentes, refrescando la información continuamente, hasta que pulsemos la tecla “q”.

alumno@maquinaLinux:~$ top
top - 17:20:19 up 24 days,  5:26,  7 users,  load average: 1.07, 1.14, 1.13
Tasks: 169 total,   1 running, 167 sleeping,   0 stopped,   1 zombie
Cpu(s):  0.3% us,  0.5% sy,  0.0% ni, 98.8% id,  0.0% wa,  0.2% hi,  0.2% si
Mem:  1295944k total,  1264724k used,    31220k free,    55088k buffers
Swap:   489448k total,   171152k used,   318296k free,   905240k cached
 
PID   USER   PR  NI  VIRT  RES  SHR  S  %CPU  %MEM  TIME+     COMMAND  
27431 alumno 16   0  2132  1116 836  R  1.3   0.1   0:00.14   top 
434   root   15   0  1632  612  520  S  0.3   0.0   27:02.57  syslogd 
518   root   16   0  27548 848  696  S  0.3   0.1   249:29.71 ippl 
1     root   16   0  1584  456  432  S  0.0   0.0   0:11.41   init 
2     root   RT   0  0     0    0    S  0.0   0.0   0:03.28   migration/0 
3     root   34  19  0     0    0    S  0.0   0.0   0:00.63   ksoftirgd/0 
4     root   RT   0  0     0    0    S  0.0   0.0   0:03.45   migration/1 
5     root   34  19  0     0    0    S  0.0   0.0   0:01.00   ksoftirgd/1 
6     root   10  -5  0     0    0    S  0.0   0.0   0:00.00   events/0 
7     root   10  -5  0     0    0    S  0.0   0.0   0:00.00   events/1 
8     root   10  -5  0     0    0    S  0.0   0.0   0:00.20   khelper 
9     root   10  -5  0     0    0    S  0.0   0.0   0:00.00   kthread 
10    root   10  -5  0     0    0    S  0.0   0.0   0:15.27   kblockd/0 
11    root   10  -5  0     0    0    S  0.0   0.0   0:11.23   kblockd/1 
14    root   15   0  0     0    0    S  0.0   0.0   8:30.86   kswapd/0 
15    root   17  -5  0     0    0    S  0.0   0.0   0:00.00   aio/0 
16    root   10  -5  0     0    0    S  0.0   0.0   0:00.00   aio/1

Teclee [Ctrl+z]. Con ello pondrá en modo suspendido al proceso del mandato top.

[2]+  Stopped                 top

El shell indica que dicho proceso ha pasado a segundo plano, con el número 2, y que está parado (Stopped).

El mandato fg trae un proceso de segundo a primer plano.

Traiga el proceso del mandato top a primer plano.

alumno@maquinaLinux:~$fg 2
top
top - 17:20:52 up 24 days,  5:26,  7 users,  load average: 1.04, 1.12, 1.13
Tasks: 169 total,   1 running, 167 sleeping,   0 stopped,   1 zombie
Cpu(s):  0.3% us,  0.5% sy,  0.0% ni, 95.9% id,  0.5% wa,  2.6% hi,  0.2% si
Mem:  1295944k total,  1267328k used,    28616k free,    55192k buffers
Swap:   489448k total,   171152k used,   318296k free,   908060k cached
 
PID   USER  PR  NI  VIRT  RES  SHR  S  %CPU  %MEM  TIME+    COMMAND  
27431 alumno 16 0   2132  1116 836  R  1.0   0.1   0:00.23  top 
624   mysql  16 0   121m  11m  1816 S  0.3   0.9   27:25.06 mysqld 
24190 root   16 0   4212  2028 1416 S  0.3   0.2   0:00.30  proftpd 
27402 alumno 16 0   14524 1876 1548 S  0.3   0.1   0:00.02  sshd 
1     root   16 0   1584  456  432  S  0.0   0.0   0:11.41  init 
2     root   RT 0   0     0    0    S  0.0   0.0   0:03.28  migration/0 
3     root   34 19  0     0    0    S  0.0   0.0   0:00.63  ksoftirgd/0 
4     root   RT 0   0     0    0    S  0.0   0.0   0:03.45  migration/1 
5     root   34 19  0     0    0    S  0.0   0.0   0:01.00  ksoftirgd/1 
6     root   10 -5  0     0    0    S  0.0   0.0   0:00.00  events/0 
7     root   10 -5  0     0    0    S  0.0   0.0   0:00.00  events/1 
8     root   10 -5  0     0    0    S  0.0   0.0   0:00.20  khelper 
9     root   10 -5  0     0    0    S  0.0   0.0   0:00.00  kthread 
10    root   10 -5  0     0    0    S  0.0   0.0   0:15.27  kblockd/0 
11    root   10 -5  0     0    0    S  0.0   0.0   0:11.23  kblockd/1 
14    root   15 0   0     0    0    S  0.0   0.0   8:30.86  kswapd/0 
15    root   17 -5  0     0    0    S  0.0   0.0   0:00.00  aio/0

Termine el proceso top con [Ctrl+c]

Traiga el proceso del mandato vmstat a primer plano.

alumno@maquinaLinux:~$fg 1
vmstat 10 >estado

Mate dicho proceso con [Ctrl+c].

Ponga en ejecución en segundo plano dos mandatos en una sola línea de mandatos.

alumno@maquinaLinux:~$ ping -i 10 138.100.8.125 > resp & vmstat > estado 10 &
[1] 27669
[2] 27670


Ejecute el mandato jobs para saber los procesos que están en segundo plano.

alumno@maquinaLinux:~$ jobs
[1]- Running                 ping -i 10 138.100.8.125 >resp &
[2]+  Running                vmstat 10 >estado &

Mate los dos procesos según lo visto anteriormente. Borre los ficheros estado y resp.


CREAR UN EJECUTABLE

Para crear un proceso hemos de tener el programa compilado y montado formando un ejecutable.

Se va a crear un proceso que ejecute el programa escrito en C, CPUyES.c. Se partirá del fichero fuente CPUyES.c.

Abra el fichero con un editor y observe el programa. Se verá que consiste en un bucle que se repite 10.000 veces, que crea unos directorios, y a continuación los borra los directorios creados. El programa no hace nada útil, simplemente consume ciclos de procesador y accesos al disco. El programa tardará bastante tiempo en terminar, por lo que le vamos a matar antes.

CE-01.- #define MYNAME	"CPUyES"
CE-02.- #include <sys/stat.h>
CE-03.- #include <sys/types.h>
CE-04.- #include <fcntl.h>
CE-05.- #include <stdio.h>
CE-06.- #include <unistd.h>
CE-07.- int main(void)
CE-08.- {
CE-09.-    int i;
CE-10.-    for (i=0; i<10000; i++) 
CE-11.-    {
CE-12.-       mkdir("tmpdir", 0777);
CE-13.-       mkdir("tmpdir/subdir", 0777);
CE-14.-       mkdir("tmpdir/subdir/subdir", 0777);
CE-15.-       sync();
CE-16.-       rmdir("tmpdir/subdir/subdir");
CE-17.-       rmdir("tmpdir/subdir");
CE-18.-       rmdir("tmpdir");
CE-19.-       sync();
CE-20.-    }
CE-21.-    return 0;
CE-22.- }

Posiciónese en el directorio especificado anteriormente y compile el programa con el compilador gcc de la siguiente forma:

alumno@maquinaLinux:~/PracticasAnalisis/ModurloArquitectura$ gcc CPUyES.c -o CPUyES
  • gcc es el compilador utilizado.
  • CPUyEs.c es el fichero con el código fuente.
  • -o CPUyES especifica el objeto a crear siendo CPUyES el fichero ejecutable.


Ejecute el mandato ps, que permite conocer los procesos en ejecución, con la opción -l que permite conocer los detalles de dichos procesos.

alumno@maquinaLinux:~/PracticasAnalisis/ModurloArquitectura> ps -l
F  S UID   PID   PPID  C  PRI  NI  ADDR  SZ  WCHAN  TTY  TIME     CMD  
0  S 27182 28429 28426 0  76   0    -    673  wait pts/0 00:00:00 bash 
0  S 27182 28454 28429 0  78   0    -    594  -    pts/0 00:00:00 ps

Con ello verá los procesos asociados al Shell desde el que se ejecuta el mandato ps (si se añade la opción -e se verán todos los procesos del sistema y si se añade la opción -u <usuario> todos los procesos de un usuario). En nuestro caso, se puede observar que hay dos procesos: el Shell (bash) cuyo PID (Process Identifier) es 28429 y el propio proceso ps con PID = 28454. Podemos observar que el padre (a) del proceso ps es el bash, puesto que su PPID (Parent Process Identifier) es 28429.
(a) El padre (parent) de un proceso es el proceso que lo ha creado (puesto en ejecución). Análogamente se denomina “hijo” (child) al proceso creado.

Ponga en ejecución el programa CPUyES en segundo plano (background):

alumno@maquinaLinux:~/PracticasAnalisis/ModuloArquitectura> ./CPUyES &
[1] 28492

Ejecute otra vez el mandato ps.

alumno@maquinaLinux:~/PracticasAnalisis/ModuloArquitectura> ps -l
F  S UID   PID   PPID  C  PRI  NI  ADDR  SZ  WCHAN  TTY  TIME     CMD  
0  S 27182 28429 28426 0  75   0    -    675 wait  pts/0 00:00:00 bash 
0  S 27182 28492 28429 99 85   0    -    358 -     pts/0 00:00:37 CPUyES 
0  S 27182 28494 28429 0  78   0    -    594 -     pts/0 00:00:00 ps

Observe que ahora hay tres procesos, puesto que se está ejecutando CPUyES.

Para matar dicho proceso use el mandato kill, al que es necesario indicarle el PID del proceso. Tenga presente que deberá poner el PID de su proceso. En nuestro caso ejecutamos:

alumno@maquinaLinux:~/PracticasAnalisis/ModuloArquitectura>kill 28492

Ejecute ps y observe que el proceso CPUyES ha terminado.

alumno@maquinaLinux:~/PracticasAnalisis/ModuloArquitectura> ps -l
F  S UID   PID   PPID  C  PRI  NI  ADDR  SZ  WCHAN  TTY  TIME     CMD  
0  S 27182 28429 28426 0  75   0    -    675 wait  pts/0 00:00:00 bash 
0  R 27182 28515 28429 0  77   0    -    595 -     pts/0 00:00:00 ps 
 
[1]+ Terminated    ./CPUyES

Rellene los siguientes datos:


PROCESOS PERIÓDICOS

El demonio cron se encarga de realizar las tareas periódicas.

En Linux, podemos automatizar tareas que se deben de realizar de manera periódica. El demonio (a) cron, que se inicia con el sistema se encarga de realizar estas tareas. En concreto, este demonio procesa unos archivos de configuración, que contiene la tarea a realizar por el Shell y la hora a la que debe realizarse.
(a) Los procesos demonio (daemon) se crean al inicio del sistema y ejecutan en background indefinidamente, realizando tareas de forma periódica o estando a la espera de eventos para dar un servicio.

Los archivos de configuración de cron se denominan crontab (forma abreviada de cron table), y cada usuario del sistema puede tener el suyo propio. Aunque los ficheros crontab de cada usuario se encuentran en el directorio /var/spool/cron/crontabs, la forma de crearlos o modificarlos es a través del mandato crontab -e.

Todos los archivos crontab tienen un formato similar, en el que los comentarios van precedidos del símbolo #. Cada línea del fichero, contendrá los siguientes campos:

  • minuto hora día mes dia_de_la_semana [nombre_de_usuario] mandato

Los cinco primeros campos se encargan de indicar el momento en el que se ejecutará el mandato

Consulte el manual de crontab (man 5 crontab) y responda a la siguiente pregunta:


 
docencia/asignaturas/sox/prv/practicas/analisis_so6/modulo_so.txt · Última modificación: 2019/05/30 11:33 (editor externo)
 
Recent changes RSS feed Powered by PHP Valid XHTML 1.0 Valid CSS Driven by DokuWiki