GESTIÓN DE PROCESOS EN SISTEMAS OPERATIVOS GNU

Gestión de procesos en sistemas operativos GNU/Linux

Luz Ayda Díaz – Martha Ramos M.

GESTIÓN DE PROCESOS EN SISTEMAS OPERATIVOS

GNU/LINUX BASADOS EN DEBIAN

Presentado por:

LUZ AYDA DÍAZ PÉREZ

MARTHA MILENA RAMOS MORILLO

Ing. SAMIR CASTAÑO

SISTEMAS OPERATIVOS

UNIVERSIDAD DE CÓRDOBA

FACULTAD DE INGENIERÍAS

PROGRAMA DE INGENIERÍA DE SISTEMAS Y TELECOMUNICACIONES

IV SEMESTRE

MONTERÍA – COLOMBIA



Sumario de Ejes

Temáticos

1. Directorio de

almacenamiento de

los procesos

2. Archivos y

directorios virtuales.

3. Comandos para

manipulación de

procesos.

4. Ejemplos de la

aplicación de dichos

comandos.

2012

INTRODUCCIÓN

En el presente documento se realizará una explicación

extensa acerca del uso y gestión de los procesos en

los sistemas operativos GNU/Linux basados en

Debian, que abarcará desde el directorio de

almacenamiento de los procesos, archivos y

directorios virtuales, comandos para manipulación de

procesos y por último, ejemplos de la aplicación de

dichos comandos.

Los sistemas Linux, como ya es sabido, son multitarea,

es decir, pueden estar ejecutando distintas acciones a

la par, y cada acción es un proceso. Se explicará como

manejar los procesos y aprovechar las características

de Linux en lo referente a la capacidad multitarea.

Cuando se ejecuta un comando en el shell, sus

instrucciones se copian en algún sitio de la memoria

RAM del sistema para ser ejecutadas. Cuando las

instrucciones ya cumplieron su función, el programa

es borrado de la memoria, dejándola libre para que

más programas se puedan ejecutar a la vez. Cada uno

de estos programas que pasan a la memoria y son

ejecutados es lo que conocemos con el nombre de

proceso. El tiempo que este proceso estuvo en la

memoria del sistema ejecutándose, se conoce como

tiempo de ejecución de un proceso.

GESTIÓN DE PROCESOS EN SISTEMAS

OPERATIVOS GNU/LINUX BASADOS EN

DEBIAN [Nombre de la compañía] [Seleccione la fecha] [Edición 1, volumen 1]



La gestión de procesos en Linux no difiere demasiado de la que se hace en

cualquier otro sistema UNIX. Así, el encargado de asignar una parte de la memoria

a un proceso es el kernel de Linux (núcleo central), quien decide cuánta memoria

dar a cada proceso.

Unos procesos serán más importantes que otros y tendrán preferencia a la hora de

pedir cálculos o instrucciones al microprocesador sobre otros procesos. Este

concepto se llama prioridad de un proceso. Por lo tanto, debe quedar claro que es

el kernel quien administra los procesos y controla su ejecución simultánea y el

reparto de los recursos de la máquina.



1. DIRECTORIO DE ALMACENAMIENTO DE PROCESOS

Los procesos son un conjunto de actividades consumidoras de recursos que

llevan a cabo tareas en el sistema operativo. Un proceso es una entidad

dinámica, cambiando constantemente a medida que el procesador ejecuta

las instrucciones de código máquina. Un proceso también incluye el

contador de programa y todos los registros de la CPU, así como las pilas del

proceso que contienen datos temporales como parámetros de las rutinas,

direcciones de retorno y variables salvadas. El programa que se está

ejecutando, o proceso, incluye toda la actividad en curso en el

microprocesador. Linux es un sistema multiproceso. Los procesos son tareas

independientes, cada una con sus propios derechos y responsabilidades.

Si un proceso se desploma, no hará que otros procesos en el sistema fallen

también. Cada proceso se ejecuta en su propio espacio de dirección virtual

y no puede haber interacciones con otros procesos excepto a través de

mecanismos seguros gestionados por el núcleo.

Durante la vida de un proceso, éste hará uso de muchos recursos del

sistema. Usará las CPUs del sistema para ejecutar sus instrucciones y la

memoria física del sistema para albergar al propio proceso y a sus datos. El

proceso abrirá y usará ficheros en los sistemas de ficheros y puede usar

dispositivos del sistema directa o indirectamente. Linux debe llevar cuentas

del proceso en sí y de los recursos de sistema que está usando de manera

que pueda gestionar este y otros procesos justamente. No sería justo para

los otros procesos del sistema que un proceso monopolizase la mayoría de

la memoria física o las CPUs.

Todo proceso ejecutado en un sistema Unix se identifica por un número

único, el Process Identifier o PID, que el sistema almacena en una tabla de

procesos para la gestión de tareas. El número PID asignado a un proceso lo

da el núcleo de Linux al iniciar el programa y no existe forma de predecirlo.

Además, un número de PID no se libera automáticamente cuando el



programa que ejecuta el proceso se cierra. De esta forma se evita el riesgo

de enviar una señal a otro proceso cuando el proceso destinario termina de

otra manera, entre el momento de uso del comando ps para identificar el

PID y el momento de ejecución del comando kill.

Los programas utilizan dos comandos para crear procesos: fork y exec. La

primera orden permite que un proceso cree un clon de sí mismo, la segunda

usa ese clon para ejecutar el código de otro programa en su lugar. De ello

resulta un parentesco entre procesos. Así, se habla de procesos hijos y

padres.

Todo proceso tiene que tener obligatoriamente un padre, salvo el primer

proceso del sistema: init. Este es pues el antecesor de todos los procesos del

sistema y su PID es 1.

Para que Linux pueda gestionar los procesos en el sistema, cada proceso se

representa por una estructura de datos task_struct (las tareas (task) y los

procesos son términos intercambiables en Linux). El vector task es una lista

de punteros a estructuras task_struct en el sistema. Esto quiere decir que el

máximo número de procesos en el sistema está limitado por el tamaño del

vector task; por defecto tiene 512 entradas. A medida que se crean

procesos, se crean nuevas estructuras task_struct a partir de la memoria del

sistema y se añaden al vector task. Para encontrar fácilmente el proceso en

ejecución, hay un puntero (current) que apunta a este proceso.

Linux soporta procesos de tiempo real así como procesos normales. Estos

procesos tienen que reaccionar muy rápidamente a sucesos externos (de ahí

el término “tiempo real”') y reciben un trato diferente del planificador.



2. ARCHIVOS Y DIRECTORIOS VIRTUALES

Los directorios y archivos de un sistema Debian tienen una estructura

standar el directorio /proc : Es un directorio "virtual", que no está

presente en el disco, es creado por el sistema para intercambiar información

con más facilidad.

Realmente no existe, sin embargo se puede explorar; Sus archivos de

tamaño 0 no son ni binarios ni textos, sin embargo se puede examinar y

desplegar su contenido.

Bajo Linux, todo es administrado como un archivo; incluso los dispositivos

son accedidos como archivos en el directorio /dev. El directorio /proc

contiene un extraño tipo de archivo: archivos virtuales. Estos archivos son

listados, pero realmente no existen en disco; el sistema operativo los crea al

vuelo.

La mayoría de los archivos virtuales siempre tienen una marca de tiempo

(timestamp) actual, lo que indica que están constantemente siendo

actualizados. El directorio /proc en si mismo es creado cada vez que

arrancas el equipo. Se requiere ser root para poder examinar

completamente el directorio en su totalidad; algunos de los archivos como

los relacionados a procesos son propiedad del usuario que los ejecutó. Y

aunque casi todos los archivos son de solo lectura, hay algunos pocos con

permisos de escritura, notablemente en /proc/sys. Que permiten realizar

cambios en los parámetros del kernel.

El sistema de archivos /proc contiene un sistema de archivos imaginario o

virtual. Este no existe físicamente en disco, sino que el núcleo lo crea en

memoria. Se utiliza para ofrecer información relacionada con el sistema

(originalmente acerca de procesos, de aquí su nombre).



Algunos de los archivos más importantes son los siguientes:

/proc/1: Un directorio con información acerca del proceso número 1. Cada

proceso tiene un directorio debajo de /proc cuyo nombre es el número de

identificación del proceso (PID).

/proc/cpuinfo: Información acerca del procesador: su tipo, marca, modelo,

rendimiento, etc.

/proc/devices: Lista de controladores de dispositivos configurados dentro

del núcleo que está en ejecución.

/proc/dma: Muestra los canales DMA que están siendo utilizados.

/proc/filesystems: Lista los sistemas de archivos que están soportados por

el kernel.

/proc/interrupts: Muestra la interrupciones que están siendo utilizadas, y

cuantas de cada tipo ha habido.

/proc/ioports: Información de los puertos de E/S que se estén utilizando en

cada momento.

/proc/kcore: Es una imagen de la memoria física del sistema. Este archivo

tiene exactamente el mismo tamaño que la memoria física, pero no existe en

memoria como el resto de los archivos bajo /proc, sino que se genera en el

momento en que un programa accede a este. (Recuerde: a menos que copie

este archivo en otro lugar, nada bajo /proc usa espacio en disco).

/proc/kmsg: Salida de los mensajes emitidos por el kernel. Estos también

son redirigidos hacia syslog.

/proc/ksyms: Tabla de símbolos para el kernel.

/proc/loadavg: El nivel medio de carga del sistema; tres indicadores

significativos sobre la carga de trabajo del sistema en cada momento.



/proc/meminfo: Información acerca de la utilización de la memoria física y

del archivo de intercambio.

/proc/modules: Indica los módulos del núcleo que han sido cargados hasta

el momento.

/proc/net: Información acerca del estado de los protocolos de red.

/proc/self: Un enlace simbólico al directorio de proceso del programa que

esté observando a /proc. Cuando dos procesos observan a /proc, obtienen

diferentes enlaces. Esto es principalmente una conveniencia para que sea

fácil para los programas acceder a su directorio de procesos.

/proc/stat: Varias estadísticas acerca del sistema, tales como el número de

fallos de página que han tenido lugar desde el arranque del sistema.

/proc/uptime: Indica el tiempo en segundos que el sistema lleva

funcionando.

/proc/versión: Indica la versión del núcleo



3. COMANDOS PARA LA MANIPULACIÓN DE

PROCESOS

El comando ps es el que permite informar sobre el estado de los

procesos. ps esta basado en el sistema de archivos /proc, es decir, lee

directamente la información de los archivos que se encuentran en este

directorio. Tiene una gran cantidad de opciones, incluso estas opciones

varían dependiendo del estilo en que se use el comando. Estas variaciones

sobre el uso de psson las siguientes:

Estilo UNIX, donde las opciones van precedidas por un guión -

Estilo BSD, donde las opciones no llevan guión

Estilo GNU, donde se utilizan nombres de opciones largas y van

precedidas por doble guión –

Sea cual sea el estilo utilizado, dependiendo de las opciones indicadas,

varias columnas se mostrarán en el listado de procesos que resulte, estas

columnas pueden ser entre muchas otras, las siguientes (y principales):

p o PID

Process ID, número único o de

identificación del proceso.

P o PPID

Parent Process ID, padre del proceso

U o UID

User ID, usuario propietario del proceso

t o TT o

TTY

Terminal asociada al proceso, si no hay

terminal aparece entonces un '?'

T o TIME

Tiempo de uso de cpu acumulado por el

proceso

c o CMD

El nombre del programa o camndo que

inició el proceso

RSS

Resident Sise, tamaño de la parte

residente en memoria en kilobytes

SZ o SIZE

Tamaño virtual de la imagen del proceso

PS



NI

Nice, valor nice (prioridad) del proceso,

un número positivo significa menos

tiempo de procesador y negativo más

tiempo (-19 a 19)

C o PCPU

Porcentaje de cpu utilizado por el proceso

STIME

Starting Time, hora de inicio del proceso

S o STAT

Status del proceso, estos pueden ser los

siguientes

R runnable, en ejecución, corriendo o

ejecutándose

S sleeping, proceso en ejecución pero sin

actividad por el momento, o esperando

por algún evento para continuar

T sTopped, proceso detenido totalmente,

pero puede ser reiniciado

Z zombie, difunto, proceso que por

alguna razón no terminó de manera

correcta, no debe haber procesos

zombies

D uninterruptible sleep, son procesos

generalmente asociados a acciones de IO

del sistema

X dead, muerto, proceso terminado pero

que sigue apareciendo, igual que los Z

no deberían verse nunca

Las opciones completas de ps las encuentras en las páginas del manual (man

ps), o escribiendo en la terminal ps L, y para ver un resumen de sus opciones

más comunes usa ps --help:

#> ps --help

********* simple selection ********* ********* selection by list *********

-A all processes -C by command name

-N negate selection -G by real group ID (supports names)

-a all w/ tty except session leaders -U by real user ID (supports names)



-d all except session leaders -g by session OR by effective group name

-e all processes -p by process ID

T all processes on this terminal -s processes in the sessions given

a all w/ tty, including other users -t by tty

g OBSOLETE -- DO NOT USE -u by effective user ID (supports

names)

r only running processes U processes for specified users

x processes w/o controlling ttys t by tty

*********** output format ********** *********** long options ***********

-o,o user-defined -f full --Group --User --pid --cols --ppid

-j,j job control s signal --group --user --sid --rows --info

-O,O preloaded -o v virtual memory --cumulative --format --deselect

-l,l long u user-oriented --sort --tty --forest --version

-F extra full X registers --heading --no-heading --context

********* misc options *********

-V,V show version L list format codes f ASCII art forest

-m,m,-L,-T,H threads S children in sum -y change -l format

-M,Z security data c true command name -c scheduling class

-w,w wide output n numeric WCHAN,UID -H process hierarchy

A continuación algunos cuantos ejemplos de ps con la salida recortada.

># ps -e (-e muestra todos los procesos)

PID TTY TIME CMD

1 ? 00:00:01 init

2 ? 00:00:00 kthreadd

3 ? 00:00:00 migration/0

4 ? 00:00:00 ksoftirqd/0

#> ps -ef (-f muestra opciones completas)

UID PID PPID C STIME TTY TIME CMD

root 1 0 0 10:12 ? 00:00:01 init [5]

root 2 0 0 10:12 ? 00:00:00 [kthreadd]

...

root 6130 5662 0 10:24 pts/0 00:00:00 su -

root 6134 6130 0 10:24 pts/0 00:00:00 -bash

sergon 6343 5604 0 10:28 ? 00:00:00 kio_file [kdeinit] file

/home/sergon/tmp/ksocket-sergon/kl

root 6475 6134 0 10:38 pts/0 00:00:00 ps -ef



#> ps -eF (-F muestra opciones completas extra)

UID PID PPID C SZ RSS PSR STIME TTY TIME CMD

root 1 0 0 412 556 1 16:59 ? 00:00:01 init [5]

root 2 0 0 0 0 1 16:59 ? 00:00:00 [kthreadd]

sergon 8326 8321 0 902 1272 0 17:07 ? 00:00:00 /bin/sh

/usr/lib/firefox-2.0.0.8/run-mozilla.sh /usr/lib/f

sergon 8331 8326 4 53856 62604 0 17:07 ? 00:00:50 /usr/lib/firefox-

2.0.0.8/mozilla-firefox-bin

sergon 8570 7726 2 15211 37948 0 17:17 ? 00:00:10 quanta

#> ps ax (formato BSD sin guión, a muestra todos, x sin mostrar tty)

PID TTY STAT TIME COMMAND

1 ? Ss 0:01 init [5]

2 ? S< 0:00 [kthreadd]

3 ? S< 0:00 [migration/0]

4 ? S< 0:00 [ksoftirqd/0]

#> ps aux (formato BSD sin guión, u muestra usuarios y demás columnas)

USER PID %CPU %MEM VSZ RSS TTY STAT START TIME

COMMAND

root 1 0.0 0.0 1648 556 ? Ss 16:59 0:01 init [5]

root 2 0.0 0.0 0 0 ? S< 16:59 0:00 [kthreadd]

root 3 0.0 0.0 0 0 ? S< 16:59 0:00 [migration/0]

root 4 0.0 0.0 0 0 ? S< 16:59 0:00 [ksoftirqd/0]

root 5 0.0 0.0 0 0 ? S< 16:59 0:00 [migration/1]

#> ps -eo user,pid,tty (-o output personalizado, se indican los campos

separados por coma, ver ps --help o ps L)

USER PID TT

root 1 ?

root 2 ?

sergon 8570 tty 1

root 8876 pts/1

#> ps -eH (muestra árbol de procesos)

#> ps axf (lo mismo en formato BSD)

#> ps -ec (el comando que se esta ejecutando, sin la ruta, solo el nombre

real)



#> ps -el (muestra formato largo de varias columnas, muy práctico)

#> ps L (No muestra procesos, lista todos los códigos de formatos)

Muestra los procesos en forma de árbol, pstree --help te da las opciones

más comunes. Recomiendo uses lo uses con la opción -A y -G para que te

un árbol con líneas con líneas estilo ASCII y de terminal VT100

respectivamente, puedes añadir también -u para mostrar entre paréntesis al

usuario propietario del proceso:

#> pstree -AGu

init---acpid

|-atd(daemon)

|-automount----2*[{automount}]

|-avahi-daemon(avahi)

|-beagled(sergon)----7*[{beagled}]

|-beagled-helper(sergio)----3*[{beagled-helper}]

|-compiz(sergon)----kde-window-deco

|-console-kit-dae----61*[{console-kit-dae}]

|-crond

|-dbus-daemon(messagebus)

|-dbus-daemon(sergio)

|-dbus-launch(sergio)

|-dcopserver(sergio)

|-dhclient

|-gam_server(sergio)

|-gconfd-2(sergio)

|-hald(haldaemon)----hald-runner(root)----hald-addon-acpi(haldaemon)

| |-hald-addon-cpuf

| |-hald-addon-inpu

| |-hald-addon-stor

|-httpd---8*[httpd(apache)]

|-2*[ifplugd]

|-ipw3945d

|-kaccess(sergio)

...

PSTREE



El comando kill, que literalmente quiere decir matar, sirve no solo para matar

o terminar procesos sino principalmente para enviar señales (signals) a los

procesos. La señal por default (cuando no se indica ninguna es terminar o

matar el proceso), y la sintaxis es kill PID, siendo PID el número de ID del

proceso. Asi por ejemplo, es posible enviar una señal de STOP al proceso y

se detendrá su ejecución, después cuando se quiera mandar una señal de

CONTinuar y el proceso continuara desde donde se quedo.

#> kill -l (lista todas las posibles señales que pueden enviarse a un

proceso)

1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL

5) SIGTRAP 6) SIGABRT 7) SIGBUS 8) SIGFPE

9) SIGKILL 10) SIGUSR1 11) SIGSEGV 12) SIGUSR2

13) SIGPIPE 14) SIGALRM 15) SIGTERM 16) SIGSTKFLT

17) SIGCHLD 18) SIGCONT 19) SIGSTOP 20) SIGTSTP

21) SIGTTIN 22) SIGTTOU 23) SIGURG 24) SIGXCPU

25) SIGXFSZ 26) SIGVTALRM 27) SIGPROF 28) SIGWINCH

29) SIGIO 30) SIGPWR 31) SIGSYS 34) SIGRTMIN

35) SIGRTMIN+1 36) SIGRTMIN+2 37) SIGRTMIN+3 38) SIGRTMIN+4



47) SIGRTMIN+13 48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14

51) SIGRTMAX-13 52) SIGRTMAX-12 53) SIGRTMAX-11 54) SIGRTMAX-10



63) SIGRTMAX-1 64) SIGRTMAX

La lista previa presenta una lista de todas las posibles señales que pueden

mandarse a un proceso y estas pueden ser invocadas a través del número de

la señal o de su código, por ejemplo:

#> kill -9 11428 (termina, mata un proceso completamente)

#> kill -SIGKILL 11428 (Lo mismo que lo anterior)

Las señales más comunes son la 19 y 20 que detienen momentáneamente la

ejecución de un proceso o programa, 18 la continua, 1 que es la señal de

hang up que obliga al proceso a releer sus archivos de configuración

estando en ejecución y 9 que termina rotundamente un proceso.

KILL



El comando killall, que funciona de manera similar a kill, pero con la

diferencia de en vez de indicar un PID se indica el nombre del programa, lo

que afectará a todos los procesos que tengan ese nombre. Asi por ejemplo

si se tienen varias instancias ejecutándose del proxy server squid, con killall

squid eliminará todos los procesos que se esten ejecutando con el nombre

'squid'

#> killall -l (lista de posibles señales)

#> killall -HUP httpd (manda una señal de "colgar", detenerse releer sus

archivos de configuración y reiniciar)

#> killall -KILL -i squid (manda señal de matar a todos los procesos squid

pero pide confirmación en cada uno)

Permite cambiar la prioridad de un proceso. Por defecto, todos los procesos

tienen una prioridad igual ante el CPU que es de 0. Con nice es posible

iniciar un programa (proceso) con la prioridad modificada, más alta o más

baja según se requiera. Las prioridades van de -20 (la más alta) a 19 la más

baja. Solo root o el superusuario puede establecer prioridades negativas que

son más altas. Con la opción -l de ps es posible observar la columna NI que

muestra este valor.

#> nice (sin argumentos, devuelve la prioridad por defecto )

0

#> nice -n -5 comando (inicia comando con una prioridad de -5, lo que le da

más tiempo de cpu)

Asi como nice establece la prioridad de un proceso cuando se incia su

ejecución, renicepermite alterarla en tiempo real, sin necesidad de detener el

proceso.

#> nice -n -5 yes (se ejecuta el programa 'yes' con prioridad -5)

(dejar ejecutando 'yes' y en otra terminal se analiza con 'ps')

#> ps -el

F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD

4 S 0 12826 12208 4 75 -5 - 708 write_ pts/2 00:00:00 yes

KILLALL

NICE

RENICE



#> renice 7 12826

12826: prioridad antigua -5, nueva prioridad 7

#> ps -el

F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD

4 S 0 12826 12208 4 87 7 - 708 write_ pts/2 00:00:15 yes

(obsérvese el campo NI en el primer caso en -5, y en el segundo con renice

quedó en 7, en tiempo real)

nohup y &

Cuando se trata ejecutar procesos en background (segundo plano) se utiliza

el comandonohup o el operador & . Aunque realizan una función similar, no

son lo mismo.

Si se desea liberar la terminal de un programa que se espera durará un

tiempo considerable ejecutándose, entonces se usa . Esto funciona mejor

cuando el resultado del proceso no es necesario mandarlo a la salida

estándar (stdin), como por ejemplo cuando se ejecuta un respaldo o se abre

un programa Xwindow desde la consola o terminal. Para lograr esto basta

con escribir el comando en cuestión y agregar al final el símbolo &

(ampersand).

$> yes > /dev/null &

$> tar czf respaldo /documentos/* > /dev/null/ &

$> konqueror & (con estos ejemplos se ejecuta el comando y se libera la

terminal regresando el prompt)

Sin embargo lo anterior produce que el padre del proceso PPID que se

invocó sea el proceso de la terminal en si, por lo que si cerramos la terminal

o salimos de la sesión también se terminaran los procesos hijos que

dependan de la terminal, no muy conveniente si se desea que el proceso

continué en ejecución.

Para solucionar lo anterior, entonces se usa el comando nohup que permite

al igual que '&' mandar el proceso y background y que este quede inmune a

los hangups (de ahí su nombre nohup) que es cuando se cuelga o termina la

terminal o consola de la cual se ejecutó el proceso.

$> nohup yes > /dev/null &

$> nohup czf respaldo /documentos/* > /dev/null/

$> nohup konqueror

Asi se evita que el proceso se "cuelgue" al cerrar la consola.



Si por ejemplo, se tiene acceso a una única consola o terminal, y se tienen

que ejecutar varios comandos que se ejecutarán por largo tiempo, se

pueden entonces como ya se vió previamente con nohup y el operador '&'

mandarlos a segundo plano o background con el objeto de liberar la

terminal y continuar trabajando.

Pero si solo se está en una terminal esto puede ser difícil de controlar, y para

eos tenemos el comando jobs que lista los procesos actuales en ejecución:

#> yes > /dev/null &

[1] 26837

#> ls -laR > archivos.txt &

[2] 26854

#> jobs

[1]- Running yes >/dev/null &

[2]+ Running ls --color=tty -laR / >archivos.txt &

En el ejemplo previo, se ejecutó el comando yes y se envió a background (&)

y el sistema devolvió [1] 26837, indicando asi que se trata del trabajo o de la

tarea [1] y su PID, lo mismo con la segunda tarea que es un listado recursivo

desde la raíz y enviado a un archivo, esta es la segunda tarea.

Con los comandos fg (foreground) y bg background es posible manipular

procesos que esten suspendidos temporalmente, ya sea porque se les envió

una señal de suspensión como STOP (20) o porque al estarlos ejecutando se

presionó ctrl-Z. Entonces para reanudar su ejecución en primer plano

usaríamos fg:

#> jobs

[1]- Stopped yes >/dev/null &

[2]+ Stopped ls --color=tty -laR / >archivos.txt &

#> fg %1

#> jobs

[1]+ Running yes >/dev/null &

[2]- Stopped ls --color=tty -laR / >archivos.txt &

Obsérvese como al traer en primer plano al 'job' o proceso 1, este adquirió

el símbolo [+] que indica que esta al frente. Lo mismo sería con bg que

volvería a reinicar el proceso pero en segundo plano. Y también es posible

JOBS



matar los procesos con kill indicando el número que devuelve jobs: kill %1,

terminaría con el proceso en jobs número 1.

Una utilería muy usada y muy útil para el monitoreo en tiempo real del

estado de los procesos y de otras variantes del sistema es el programa

llamado top, se ejecuta desde la línea de comandos, es interactivo y por

defecto se actualiza cada 3 segundos.

$> top

top - 13:07:30 up 8 days, 6:44, 4 users, load average: 0.11, 0.08, 0.08

Tasks: 133 total, 1 running, 131 sleeping, 0 stopped, 1 zombie

Cpu(s): 0.0%us, 0.2%sy, 0.0%ni, 99.7%id, 0.0%wa, 0.0%hi, 0.2%si, 0.0%st

Mem: 497356k total, 472352k used, 25004k free, 21500k buffers

Swap: 1156640k total, 257088k used, 899552k free, 60420k cached

PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND

26156 sergon 15 0 2160 1016 784 R 1 0.2 0:00.93 top

1 root 15 0 2012 616 584 S 0 0.1 0:00.98 init

2 root RT 0 0 0 0 S 0 0.0 0:00.29 migration/0

3 root 34 19 0 0 0 S 0 0.0 0:00.00 ksoftirqd/0

4 root RT 0 0 0 0 S 0 0.0 0:00.00 watchdog/0

5 root RT 0 0 0 0 S 0 0.0 0:00.38 migration/1

...

Estando adentro de la apliación, presionando 'h' muestra una ayuda de los

posibles comandos que permiten configurar top, por ejemplo, al presionar

's' pregunta por el tiempo en segundos de actualización, etc.

Estas son algunas de las herramientas, las más importantes y usadas, para

adminsitrar procesos, hay varios programas en ambientes gráficos que en

una sola pantalla permiten todo lo anterior y más, y en línea de comandos te

recomiendo htop, que es como un top pero en esteroides.

TOP

http://htop.sourceforge.net/



4. EJEMPLOS DE LA APLICACIÓN DE COMANDOS

PARA LA MANIPULACIÓN DE PROCESOS



CONCLUSIÓN

A partir de la investigación realizada, podemos establecer que la Gestión de

Procesos en los sistemas operativos GNU/Linux basados en Debian, es realizada

por el kernel o núcleo central del sistema operativo. Cada proceso tiene un número

identificador del mismo, un número identificador del proceso padre, un estado,

dueño y una prioridad.

Además de ello, existen ciertos comandos para manipular los procesos de

ejecución del sistema operativo. Entre ellos encontramos ps, pstree, kill, killall, nice,

renice, job, top, comandos que permiten al usuario interactuar con la máquina en

la administración de dichos procesos, permitiendo la rentabilidad de la memoria de

CPU y la agilización del funcionamiento de la misma.



BIBLIOGRAFÍA RELACIONADA

http://personal.us.es/echevarria/documentos/ManualLinuxZonaSiete.pdf

LINUX. Principios básicos del uso del sistema. Ediciones ENI. Serie: Recursos

Informáticos.

Guía oficial de instalación de Debian 6.0. en el sitio web oficial de Debian.

Sitio web oficial de GNU: http://www.gnu.org/home.es.html.

http://sopa.dis.ulpgc.es/ii-

dso/leclinux/procesos/planificador/LEC6_CHEDULER.pdf

GESTIÓN DE PROCESOS EN SISTEMAS OPERATIVOS GNU

Documents

Transcript of GESTIÓN DE PROCESOS EN SISTEMAS OPERATIVOS GNU