ERROR USUARIO NO VALIDADO 1
El módulo de arquitectura e introducción al sistema operativo se estructura en los siguientes apartados:
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:
Los mandatos externos (ejecutables) utilizados en este módulo son los siguientes:
Del directorio etc se manejará el siguiente fichero:
Del directorio proc se manejarán los siguientes subdirectorios y ficheros:
Se utilizarán los siguientes programas:
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.
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.
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.
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.
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.
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.
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
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:
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
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.
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.
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
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:
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:
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.
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
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:
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:
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: