Identificar los procesos que hacen un uso intensivo de la CPU y de la memoria ajustar la prioridad de los procesos con renice y eliminar procesos

En esta parte de los Objetivos de RHCSA, aprenderemos como Identificar los procesos, dar prioridades y eliminarlos, daremos una pequeña introduccion antes que todo.

La más simple definición de un proceso podría ser que es una instancia de un programa en ejecución (corriendo). A los procesos frecuentemente se les refiere como tareas. El contexto de un programa que esta en ejecución es lo que se llama un proceso. Este contexto puede ser mas procesos hijos que se hayan generado del principal (proceso padre), los recursos del sistema que este consumiendo, sus atributos de seguridad (tales como su propietario y permisos de archivos asi como roles y demás de SELinux), etc.

Los procesos en Linux (o en cualquier sistema operativo) son programas que están en ejecución y se identifican mediante el PID.
El PID (Process Identificator) es el número que se le asigna a un proceso cuando se inicia. Son números crecientes y los procesos que se terminan y luego se vuelven a iniciar van a tener un PID diferente. Por ejemplo, el PID número 1 se le asigna a por norma general a init que es el primer proceso que inicia el sistema al ser arrancado.

A través de la rutina de fork, un proceso hijo hereda identidades de seguridad, descriptores de archivos anteriores y actuales, privilegios de puerto y de recursos, variables de entorno y código de programa.

Un proceso secundario puede entonces ejecutar (exec) su propio código de programa
Normalmente, un proceso padre duerme (sleeps) mientras se ejecuta el proceso secundario, estableciendo una petición espera (wait) para que se señale cuando el hijo termina. Al salir, el proceso hijo ya ha cerrado o descartado sus recursos y el medio ; El resto se refiere como un zombi.

 

Un proceso puede tener estados básicos de:

S – Sleep Durmiendo. Quiere decir que está en ejecución, pero en ese momento no se encuentra ejecutándose ningún código dentro de la CPU.
D – Sleep Es igual que el anterior, pero no es posible interrumpirlo.
T – Stopped Parado. Quiere decir que se ha detenido su ejecución.
R – Running En ejecución. Es un proceso que se está ejecutando de forma activa en la CPU.
Z – Zombie Es un proceso que debería de haber muerto, pero aún tiene dependencias que no es posible terminar. Hasta que no se eliminen sus dependencias no desaparecerá.

Un proceso que está en ejecución en primer plano, es decir, en la consola, puede ser detenido mediante la pulsación de ^C (Ctrl+C). Esta comando, envía al proceso activo la señal de SIGTERM.

Si se presiona la combinación de teclas ^Z (Ctrl+Z), se enviará la señal de SIGSTOP. Para volver a retomar el proceso ejecutar el comando fg.

La ejecución de los procesos se puede ver con el comando ps xa

[root@rhel ~]# ps xa
PID TTY STAT TIME COMMAND
1 ? Ss 0:01 /usr/lib/systemd/systemd --switched-root --system --deserialize 21
2 ? S 0:00 [kthreadd]
3 ? S 0:00 [ksoftirqd/0]
4 ? S 0:00 [kworker/0:0]
5 ? S< 0:00 [kworker/0:0H]
6 ? S 0:00 [kworker/u2:0]
7 ? S 0:00 [migration/0]
8 ? S 0:00 [rcu_bh]
9 ? S 0:00 [rcuob/0]
10 ? R 0:00 [rcu_sched]
11 ? S 0:00 [rcuos/0]
12 ? S 0:00 [watchdog/0]
13 ? S< 0:00 [khelper]
14 ? S 0:00 [kdevtmpfs]
15 ? S< 0:00 [netns]

............................................

.............................................

[root@rhel ~]#

La dependencia de procesos puede verse con el comando: pstree

[root@rhel ~]# pstree
systemd─┬─ModemManager───2*[{ModemManager}]
├─NetworkManager───2*[{NetworkManager}]
├─2*[abrt-watch-log]
├─abrtd
├─accounts-daemon───2*[{accounts-daemon}]
├─alsactl
├─at-spi-bus-laun─┬─dbus-daemon───{dbus-daemon}
│ └─3*[{at-spi-bus-laun}]
├─at-spi2-registr───{at-spi2-registr}
├─atd
├─auditd─┬─audispd─┬─sedispatch
│ │ └─{audispd}
│ └─{auditd}
├─avahi-daemon───avahi-daemon
├─caribou───2*[{caribou}]
├─chronyd
├─colord───2*[{colord}]
├─crond
├─cupsd
├─2*[dbus-daemon───{dbus-daemon}]
├─dbus-launch
├─dconf-service───2*[{dconf-service}]
├─dnsmasq───dnsmasq
├─gdm─┬─Xorg
│ ├─gdm-session-wor─┬─gnome-session─┬─gnome-settings-───5*[{gnome-settings-}]
│ │ │ ├─gnome-shell─┬─ibus-daemon─┬─ibus-dconf───3*[{ibus-dconf}]
│ │ │ │ │ ├─ibus-engine-sim───2*[{ibus-engine-sim}]
│ │ │ │ │ └─2*[{ibus-daemon}]
│ │ │ │ └─6*[{gnome-shell}]
│ │ │ └─3*[{gnome-session}]
│ │ └─2*[{gdm-session-wor}]
│ └─3*[{gdm}]
├─goa-daemon───3*[{goa-daemon}]
├─goa-identity-se───2*[{goa-identity-se}]
├─gssproxy───5*[{gssproxy}]
├─gvfs-afc-volume───2*[{gvfs-afc-volume}]
├─gvfs-goa-volume───{gvfs-goa-volume}
├─gvfs-gphoto2-vo───{gvfs-gphoto2-vo}
├─gvfs-mtp-volume───{gvfs-mtp-volume}
├─gvfs-udisks2-vo───2*[{gvfs-udisks2-vo}]
├─gvfsd───{gvfsd}
├─ibus-x11───2*[{ibus-x11}]
├─ksmtuned───sleep
├─libvirtd───15*[{libvirtd}]
├─lsmd
├─lvmetad
├─master─┬─pickup
│ └─qmgr
├─mission-control───2*[{mission-control}]
├─packagekitd───2*[{packagekitd}]
├─pcscd───2*[{pcscd}]
├─polkitd───5*[{polkitd}]
├─pulseaudio───2*[{pulseaudio}]
├─rsyslogd───2*[{rsyslogd}]
├─rtkit-daemon───2*[{rtkit-daemon}]
├─smartd
├─sshd───sshd───bash───pstree
├─systemd-journal
├─systemd-logind
├─systemd-udevd
├─tuned───4*[{tuned}]
├─udisksd───4*[{udisksd}]
├─upowerd───2*[{upowerd}]
└─wpa_supplicant
[root@rhel ~]#

ps mostrará los procesos del usuario con el que estamos logueados.

[root@rhel ~]# ps
PID TTY TIME CMD
2518 pts/0 00:00:00 bash
3199 pts/0 00:00:00 ps
[root@rhel ~]#

Por otra parte, los parámetros más básicos a conocer son los siguientes:

-aux Lista los procesos de todos los usuarios con información añadida

[root@rhel ~]# ps aux
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
root 1 0.2 0.7 126576 7316 ? Ss 09:22 0:01 /usr/lib/systemd/systemd --switched-root --system --deserialize 21
root 2 0.0 0.0 0 0 ? S 09:22 0:00 [kthreadd]
root 3 0.0 0.0 0 0 ? S 09:22 0:00 [ksoftirqd/0]
root 5 0.0 0.0 0 0 ? S< 09:22 0:00 [kworker/0:0H]
root 6 0.0 0.0 0 0 ? S 09:22 0:00 [kworker/u2:0]
root 7 0.0 0.0 0 0 ? S 09:22 0:00 [migration/0]
root 8 0.0 0.0 0 0 ? S 09:22 0:00 [rcu_bh]
root 9 0.0 0.0 0 0 ? S 09:22 0:00 [rcuob/0]
root 10 0.0 0.0 0 0 ? R 09:22 0:00 [rcu_sched]
root 11 0.0 0.0 0 0 ? S 09:22 0:00 [rcuos/0]
root 12 0.0 0.0 0 0 ? S 09:22 0:00 [watchdog/0]
root 13 0.0 0.0 0 0 ? S< 09:22 0:00 [khelper]
root 14 0.0 0.0 0 0 ? S 09:22 0:00 [kdevtmpfs]
root 15 0.0 0.0 0 0 ? S< 09:22 0:00 [netns]
root 16 0.0 0.0 0 0 ? S< 09:22 0:00 [perf]
root 17 0.0 0.0 0 0 ? S< 09:22 0:00 [writeback]

................................................................................

-a Lista los procesos de todos los usuarios en tiempo real

[root@rhel ~]# ps -a
PID TTY TIME CMD
3324 pts/0 00:00:00 ps
[root@rhel ~]#

-u Lista información del proceso como por ejemplo el usuario que lo está corriendo, la utilización de Cpu y memoria

[root@rhel ~]# ps -u
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
root 1460 0.0 1.4 204244 14420 tty1 Ss+ 09:23 0:00 /usr/bin/Xorg :0 -background none -noreset -audit 4 -verbose -auth /run/gdm/auth-for-gdm-pSa
root 2518 0.0 0.3 123108 3500 pts/0 Ss 09:24 0:00 -bash
root 3346 0.0 0.1 139492 1632 pts/0 R+ 09:35 0:00 ps -u
[root@rhel ~]#

-x Lista procesos de todas las terminales y usuarios

[root@rhel ~]# ps -x
PID TTY STAT TIME COMMAND
1 ? Ss 0:01 /usr/lib/systemd/systemd --switched-root --system --deserialize 21
2 ? S 0:00 [kthreadd]
3 ? S 0:00 [ksoftirqd/0]
5 ? S< 0:00 [kworker/0:0H]
6 ? S 0:00 [kworker/u2:0]
7 ? S 0:00 [migration/0]
8 ? S 0:00 [rcu_bh]
9 ? S 0:00 [rcuob/0]
10 ? S 0:00 [rcu_sched]
11 ? R 0:00 [rcuos/0]
12 ? S 0:00 [watchdog/0]
13 ? S< 0:00 [khelper]
14 ? S 0:00 [kdevtmpfs]
15 ? S< 0:00 [netns]
16 ? S< 0:00 [perf]
17 ? S< 0:00 [writeback]
18 ? S< 0:00 [kintegrityd]
19 ? S< 0:00 [bioset]
20 ? S< 0:00 [kblockd]
21 ? S< 0:00 [md]

................................................


[root@rhel ~]# ps -x

-l Muestra información que incluye el UID y el valor “nice“.

[root@rhel ~]# ps -l
F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD
4 S 0 2518 2513 0 80 0 - 30777 wait pts/0 00:00:00 bash
0 R 0 3462 2518 0 80 0 - 34343 - pts/0 00:00:00 ps
[root@rhel ~]#

No olvidemos el comando top, es una interfaz en modo texto que se va a ir actualizando cada 3 segundos. Muestra un resumen del estado de nuestro sistema y la lista de procesos que se están ejecutando en tiempo real

top - 09:40:35 up 17 min, 2 users, load average: 0,00, 0,03, 0,10
Tasks: 132 total, 2 running, 130 sleeping, 0 stopped, 0 zombie
%Cpu(s): 0,0/0,0 0[ ]
KiB Mem : 1016860 total, 454396 free, 251140 used, 311324 buff/cache
KiB Swap: 0 total, 0 free, 0 used. 603228 avail Mem
[root@rhel ~]# top

PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
11 root 20 0 0 0 0 R 0,3 0,0 0:01.00 rcuos/0
1 root 20 0 126576 7316 2608 S 0,0 0,7 0:01.62 systemd
2 root 20 0 0 0 0 S 0,0 0,0 0:00.00 kthreadd
3 root 20 0 0 0 0 S 0,0 0,0 0:00.09 ksoftirqd/0
5 root 0 -20 0 0 0 S 0,0 0,0 0:00.00 kworker/0:0H
6 root 20 0 0 0 0 S 0,0 0,0 0:00.01 kworker/u2:0
7 root rt 0 0 0 0 S 0,0 0,0 0:00.00 migration/0
8 root 20 0 0 0 0 S 0,0 0,0 0:00.00 rcu_bh
9 root 20 0 0 0 0 S 0,0 0,0 0:00.00 rcuob/0
10 root 20 0 0 0 0 S 0,0 0,0 0:00.49 rcu_sched
12 root rt 0 0 0 0 S 0,0 0,0 0:00.00 watchdog/0

......................................................

Analisemos las cabeceras

Tiempo de actividad y carga media del sistema

top - 09:40:43 up 17 min, 2 users, load average: 0,00, 0,03, 0,10

En la primera línea nos muestra:

  1. Hora actual.
  2. Tiempo que ha estado el sistema encendido.
  3. Número de usuarios (2 users).
  4. Carga media en intervalos de 5, 10 y 15 minutos respectivamente.

     Tareas

    Tasks: 132 total, 2 running, 130 sleeping, 0 stopped, 0 zombie

    La segunda línea muestra el total de tareas y procesos, los cuales pueden estar en diferentes estados

  5. Running (ejecutar): procesos ejecutándose actualmente o preparados para ejecutarse.
  6. Sleeping (hibernar): procesos dormidos esperando que ocurra algo (depende del proceso) para ejecutarse.
  7. Stopped (detener): ejecución de proceso detenida.
  8. Zombie: el proceso no está siendo ejecutado. Estos procesos se quedan en este estado cuando el proceso que los ha iniciado muere (padre).

     Estados de la CPU

    KiB Mem : 1016860 total, 454364 free, 251172 used, 311324 buff/cache
  9.  Memoria total.
  10. Memoria utilizada.
  11. Memoria libre.
  12. Memoria utilizada por buffer.

    Memoria virtual

    KiB Swap: 0 total, 0 free, 0 used. 603196 avail Mem
  13.  Memoria total.
  14. Memoria usada.
  15. Memoria libre.
  16. Memoria en caché

     Columnas

        PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
        406 root 20 0 0 0 0 S 0,3 0,0 0:00.40 xfsaild/dm-0
        3597 root 20 0 146144 2084 1424 R 0,3 0,2 0:00.10 top
        1 root 20 0 126576 7316 2608 S 0,0 0,7 0:01.62 systemd
        2 root 20 0 0 0 0 S 0,0 0,0 0:00.00 kthreadd
        3 root 20 0 0 0 0 S 0,0 0,0 0:00.09 ksoftirqd/0
    
    .....................................
  • PID: es el identificador de proceso. Cada proceso tiene un identificador único.
  • USER (USUARIO): usuario propietario del proceso.
  • PR: prioridad del proceso. Si pone RT es que se está ejecutando en tiempo real.
  • NI: asigna la prioridad. Si tiene un valor bajo (hasta -20) quiere decir que tiene más prioridad que otro con valor alto (hasta 19).
  • VIRT: cantidad de memoria virtual utilizada por el proceso.
  • RES: cantidad de memoria RAM física que utiliza el proceso.
  • SHR: memoria compartida.
  • S (ESTADO): estado del proceso.
  • %CPU: porcentaje de CPU utilizado desde la última actualización.
  • %MEM: porcentaje de memoria física utilizada por el proceso desde la última actualización.
  • TIME+ (HORA+): tiempo total de CPU que ha usado el proceso desde su inicio.
  • COMMAND: comando utilizado para iniciar el proceso

Trabajos en ejecución en el Segundo plano
Cualquier comando puede iniciarse en segundo plano mediante la adición de un signo & (ampersand) en la línea de comandos, el shell de bash muestra un número de trabajo (exclusivo para la sesión) y el PID del proceso nuevo hijo. El shell de comandos no espera al proceso secundario y vuelve a mostrar el indicador de shell

[root@rhel ~]# sleep 1000 &
[1] 4404
[root@rhel ~]#

El shell de comandos bash hace un seguimiento de los trabajos, por sesión en la tabla mostrada con el comando jobs

[root@rhel ~]# jobs
[1]+ Ejecutando sleep 1000 &
[root@rhel ~]#

El segundo plano no puede volver a conectarse al terminal de control al ser llevado al primer plano utilizando el comando fg con el ID del trabajo (% job numero)

[root@rhel ~]# fg %1
sleep 1000
___

Paramos en proceso con la opcion (Ctrl -z)

[root@rhel ~]# fg %1
sleep 1000
-
^Z
[1]+ Detenido sleep 1000
[root@rhel ~]#

Ejecutaremos un proceso continuamente agregando la palabra “redhat” y un espacio entre al archivo ~/outfile en un segundo intervalo.El Conjunto de comandos completos debe estar entre parentesis para el control del trabajo para interpretar el conjunto como unico trabajo

[root@rhel ~]# (while true; do echo -n "redhat" >> ~/outfile; sleep 1; done)

En otra terminal, use tail para confirmar que los nuevos procesos estan escribiendo al archivo.

[root@rhel ~]# tail -f ~/outfile
redhatredhatredhatredhatredhatredhatredhatredhatredhatredhatredhatredhatredhatre dhatredhatredhatredhatredhatredhatredhatredhatredhatredhatredhatredhatredhat.................

.......................................................................

Para suspender, simplemente (Ctrl -z)

[root@rhel ~]# tail -f ~/outfile
redhatredhatredhatredhatredhatredhatredhatredhatredhatredhatredhatredhatredhatre dhatredhatredhatredhatredhatredhatredhatredhatredhatredhatredhatredhatredhatredh atredhatredhatredhatredhatredhatredhatredhatredhatredhatredhatredhatredhatredhatredhatredhatredhatredhatredhatredh
[1]+ Detenido tail -f ~/outfile
[root@rhel ~]#

Matando Procesos

Ya vimos como identicar los procesos, lo diferentes usos de la CPU, la memoria, etc..ahora nos concentraremos en la partes de procesos de control mediantes señales y como dar prioridades a las tareas..Cada proceso que se ejecuta en el sistema operativo está preparado para recibir una serie de señales y actuar en consecuencia. El comando kill es el empleado de forma cotidiana para enviar de forma manual estas señales

Tipos de Señales:

1 SIGHUP El modem ha detectado línea telefónica colgada
2 SIGINT Interrupción de teclado, la tecla DEL ha sido pulsada
3 SIGQUIT Señal Quit (desde el teclado CTRL \)
4 SIGILL Instrucción ilegal
5 SIGTRAP Traza de los traps (excepciones)
6 SIGABRT Abortar un programa
7 SIGBUS Error en el Bus
8 SIGFPE Excepción por rebosamiento de coma flotante
9 SIGKILL Matar un proceso
10 SIGUSR1 El usuario define la señal # 1
11 SIGSEGV Violación de segmentación
12 SIGUSR2 El usuario define la señal # 2
13 SIGPIPE Escritura en pipe sin lectores
14 SIGALRM Alarma
15 SIGTERM Software genera una señal de terminación
16 SIGSTKFLT Fallo en el stack
17 SIGCHLD Cambia el estado del hijo, terminado o bloqueado
18 SIGCONT Si está bloqueado continuar
19 SIGSTOP Señal de paro
20 SIGTSTP Paro del teclado
21 SIGTTIN Proceso en segundo plano quiere leer, lectura terminal
22 SIGTTOU Proceso en segundo plano quiere escribir, escritura terminal
23 SIGURG Condición urgente
24 SIGXCPU Excedido el límite de la CPU
25 SIGXFSZ Excedido el limite del tamaño de un fichero
26 SIGVTALRM Alarma del reloj virtual
27 SIGPROF Historial del reloj
28 SIGWINCH Cambia el tamaño de la ventana
29 SIGIO Ahora es posible la entrada salida
30 SIGPWR Fallo en la alimentación
31 SIGSYS Llamada al sistema erronea
32 SIGRTMIN Primera señal en tiempo real
33 SIGRTMAX Última señal en tiempo real

Comenzaremos 3 procesos que escribiran textos de salida en un intervalo de un segundo.

[root@rhel ~]# (while true; do echo -n "play" >> ~/outfile; sleep 1; done)&
[1] 7355
[root@rhel ~]# (while true; do echo -n "run" >> ~/outfile; sleep 1; done)&
[2] 7381
[root@rhel ~]# (while true; do echo -n "swim" >> ~/outfile; sleep 1; done)&
[3] 7416
[root@rhel ~]#

En otra terminal usamos tail, para confirmar que todos los procesos estan agregando al archivo

[root@rhel ~]# tail -f ~/outfile
ayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswimredhatplayrunswim^C
[root@rhel ~]

vemos los trabajos que estan ejecutando en tiempo real

[root@rhel ~]# jobs
[1] Ejecutando ( while true; do
echo -n "play" >> ~/outfile; sleep 1;
done ) &
[2]- Ejecutando ( while true; do
echo -n "run" >> ~/outfile; sleep 1;
done ) &
[3]+ Ejecutando ( while true; do
echo -n "swim" >> ~/outfile; sleep 1;
done ) &
[root@rhel ~]#

Como ven cada proceso tiene un numero play [1], run [2], swim [3]. Ahora suspendamos el proceso “play” enviando una señal (haslo esto en 2 terminales para que te sea mas comodo), Si no recuerdas los nombres de las señales no te preocupes esto te ayudara kill -l

[root@rhel ~]# kill -l
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 39) SIGRTMIN+5 40) SIGRTMIN+6 41) SIGRTMIN+7 42) SIGRTMIN+8
43) SIGRTMIN+9 44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12 47) SIGRTMIN+13
48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14 51) SIGRTMAX-13 52) SIGRTMAX-12
53) SIGRTMAX-11 54) SIGRTMAX-10 55) SIGRTMAX-9 56) SIGRTMAX-8 57) SIGRTMAX-7
58) SIGRTMAX-6 59) SIGRTMAX-5 60) SIGRTMAX-4 61) SIGRTMAX-3 62) SIGRTMAX-2
63) SIGRTMAX-1 64) SIGRTMAX
[root@rhel ~]#

Lo que queremos es que  pare el proceso “play” como habiamos dicho

[root@rhel ~]# jobs
[1] Ejecutando ( while true; do
echo -n "play" >> ~/outfile; sleep 1;
done ) &
[2]- Ejecutando ( while true; do
echo -n "run" >> ~/outfile; sleep 1;
done ) &
[3]+ Ejecutando ( while true; do
echo -n "swim" >> ~/outfile; sleep 1;
done ) &
[root@rhel ~]# kill -SIGSTOP %1
[root@rhel ~]# jobs
[1]+ Detenido ( while true; do
echo -n "play" >> ~/outfile; sleep 1;
done )
[2] Ejecutando ( while true; do
echo -n "run" >> ~/outfile; sleep 1;
done ) &
[3]- Ejecutando ( while true; do
echo -n "swim" >> ~/outfile; sleep 1;
done ) &
[root@rhel ~]#

Como ven el proceso “play” se ha detenido con kill -SIGSTOP %1, lo puedes visualizar en tu otra terminal y los demas siguen ejecutando, ahora probamos terminar el proceso “run”

[root@rhel ~]# kill -15 %2
[root@rhel ~]# jobs
[1]+ Detenido ( while true; do
echo -n "play" >> ~/outfile; sleep 1;
done )
[2] Terminado ( while true; do
echo -n "run" >> ~/outfile; sleep 1;
done )
[3]- Ejecutando ( while true; do
echo -n "swim" >> ~/outfile; sleep 1;
done ) &
[root@rhel ~]#

Como ven el proceso “run” ha terminado , en este caso he usado el numero de la señal 15 ) SIGTERM . Para que continue un proceso lo hacemos de esta manera

[root@rhel ~]# jobs
[3]+ Detenido ( while true; do
echo -n "swim" >> ~/outfile; sleep 1;
done )
[root@rhel ~]# kill -SIGCONT %3
[root@rhel ~]# jobs
[3]+ Ejecutando ( while true; do
echo -n "swim" >> ~/outfile; sleep 1;
done ) &
[root@rhel ~]#

Esto es todo, queda a su cargo practicarlo como a usted le paresca…Para no dejar pasar tambien los mostrare como matar procesos de conexiones ssh por ejemplo de algun usuario que se este conectando a nuestro equipo desprevenidamente

Registrar usuarios

Con el comando w vemos los usuario conectados recientemente dentro del sistema y sus actividades, usando TTY y From la ubicacion del usuario. Los usuarios remotos muestran el nombre del sistema de conexión en las columnas from con  la opción -f

[root@rhel ~]# w
11:42:40 up 2:19, 5 users, load average: 0,00, 0,01, 0,05
USER TTY FROM LOGIN@ IDLE JCPU PCPU WHAT
root pts/0 informatica-152. 09:24 1:05m 2.43s 0.00s sleep 1
root pts/1 informatica-152. 10:38 0.00s 1.34s 0.03s w
root pts/2 172.16.55.254 11:41 56.00s 0.03s 0.03s -bash
manu pts/3 informatica-152. 11:42 8.00s 0.03s 0.00s ping 172.16.0.200
[root@rhel ~]# w -f
11:42:42 up 2:19, 5 users, load average: 0,00, 0,01, 0,05
USER TTY LOGIN@ IDLE JCPU PCPU WHAT
root pts/0 09:24 1:05m 2.43s 0.00s sleep 1
root pts/1 10:38 2.00s 1.31s 0.00s w -f
root pts/2 11:41 58.00s 0.03s 0.03s -bash
manu pts/3 11:42 10.00s 0.03s 0.00s ping 172.16.0.200

Con el comando last, puedes ver el historial de conexiones

[root@rhel ~]# last
root     pts/2        172.16.150.250   Wed Jul  5 10:04   still logged in
manu     pts/1        informatica-76.m Wed Jul  5 09:36   still logged in
root     pts/0        informatica-76.m Wed Jul  5 09:36   still logged in
administ :0           :0               Wed Jul  5 07:31   still logged in
root     pts/0        172.16.150.250   Tue Jul  4 14:11 - 08:36  (18:25)
manu     pts/3        informatica-152. Tue Jul  4 11:49 - 14:49  (03:00)
manu     pts/3        informatica-152. Tue Jul  4 11:42 - 11:46  (00:04)

Para terminar los procesos para un usuario, utilice el commado del pkill..vemos que el usuario manu esta conectado por ssh desde informatica-152 y esta ejecutando el comando ping 172.16.0.200, le enviaremos un señal para interrumpir su conexion

[root@rhel ~]# pgrep -l -u manu
15483 sshd
15487 bash
15591 ping
[root@rhel ~]#

[root@rhel ~]# pkill -SIGTERM -u manu


Como ven el usuario manu ha perdido la conexion, simple verdad, les dejo algunos comandos que le podrian interesar y hacer uso de ello, Solo le mostre una parte aca 🙂

[root@rhel ~]# w
11:52:32 up 2:29, 5 users, load average: 0,24, 0,06, 0,06
USER TTY FROM LOGIN@ IDLE JCPU PCPU WHAT
root pts/0 informatica-152. 09:24 1:15m 2.85s 0.00s sleep 1
root pts/1 informatica-152. 10:38 0.00s 1.64s 0.00s w
root pts/2 172.16.55.254 11:41 40.00s 0.05s 0.01s ping 172.16.0.200
manu pts/3 informatica-152. 11:49 2:46 0.03s 0.03s -bash
[root@rhel ~]# w -h -u manu
manu pts/3 informatica-152. 11:49 2:58 0.03s 0.03s -bash
[root@rhel ~]# pstree -p manu
sshd(16671)───bash(16674)
[root@rhel ~]# pkill -P 16671
[root@rhel ~]#

Comandos “nice” y “renice”

Cada proceso en el sistema está corriendo con prioridades definidas. Este valor puede variar desde -20 a +20. La máxima prioridad para los procesos es -20. Si no está definido, cada proceso correrá con prioridad 0 de manera predeterminada (la prioridad “base” para la administración de procesos) Los procesos con prioridad máxima (cualquier valor negativo hasta -20) usan más recursos del sistema que otros. Los procesos con prioridad mínima (+20) funcionarán cuando otras tareas no usen el sistema. Los usuarios que no sean el superusuario sólo pueden bajar la prioridad de los procesos que poseen en el rango de 0 a 20.

El superusuario (root) puede ajustar la prioridad de los procesos a cualquier valor

nice

El comando nice en Linux nos permite modificar la prioridad de un proceso frente al resto dentro del sistema.

Para ver todos los procesos en Tiempo real podemos usar top, o si quisieramos obtener una instantanea de los procesos en el Sistema ejecutamos ps aux, usted puede utilizar la heramienta pipe ( | ) para especificar el nombre_del_proceso

#top

top - 09:10:32 up 12 days, 18:55, 2 users, load average: 0,00, 0,01, 0,05
Tasks: 140 total, 1 running, 139 sleeping, 0 stopped, 0 zombie
%Cpu(s): 0,0/0,0 0[ ]
KiB Mem : 3881776 total, 2988140 free, 344516 used, 549120 buff/cache
KiB Swap: 0 total, 0 free, 0 used. 3072256 avail Mem

PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
23 root 20 0 0 0 0 S 0,3 0,0 0:01.93 ksoftirqd/3
1 root 20 0 128096 6644 3888 S 0,0 0,2 0:49.80 systemd
2 root 20 0 0 0 0 S 0,0 0,0 0:00.19 kthreadd
3 root 20 0 0 0 0 S 0,0 0,0 0:00.05 ksoftirqd/0
5 root 0 -20 0 0 0 S 0,0 0,0 0:00.00 kworker/0:0H
7 root rt 0 0 0 0 S 0,0 0,0 0:00.41 migration/0
8 root 20 0 0 0 0 S 0,0 0,0 0:00.00 rcu_bh
9 root 20 0 0 0 0 S 0,0 0,0 1:12.17 rcu_sched
10 root rt 0 0 0 0 S 0,0 0,0 0:04.79 watchdog/0
11 root rt 0 0 0 0 S 0,0 0,0 0:04.23 watchdog/1
12 root rt 0 0 0 0 S 0,0 0,0 0:00.44 migration/1

..........................................

 # ps aux

[root@server1 ~]# ps aux
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
root 1 0.0 0.1 128096 6644 ? Ss jun22 0:49 /usr/lib/systemd/systemd --switched-root --system --deserialize 20
root 2 0.0 0.0 0 0 ? S jun22 0:00 [kthreadd]
root 3 0.0 0.0 0 0 ? S jun22 0:00 [ksoftirqd/0]
root 5 0.0 0.0 0 0 ? S< jun22 0:00 [kworker/0:0H]
root 7 0.0 0.0 0 0 ? S jun22 0:00 [migration/0]
root 8 0.0 0.0 0 0 ? S jun22 0:00 [rcu_bh]
root 9 0.0 0.0 0 0 ? S jun22 1:12 [rcu_sched]
root 10 0.0 0.0 0 0 ? S jun22 0:04 [watchdog/0]
root 11 0.0 0.0 0 0 ? S jun22 0:04 [watchdog/1]
root 12 0.0 0.0 0 0 ? S jun22 0:00 [migration/1]

.........................................
Obs: Es necesario ser root para poder utilizar  el comando nice, nice por defecto es 0
[root@server1 ~]# nice
0
[root@server1 ~]#

Así pues, si quisiéramos ejecutar un proceso con una mayor prioridad  haríamos lo siguiente, en este ejemplo probaremos con una script

[root@server1 ~]# nice -n -20 ./proxy.sh
Debo de pasar el Examen de RHCSA
[root@server1 ~]# ps al |grep proxy.sh
0 0 20650 20079 20 0 112668 924 pipe_w S+ pts/1 0:00 grep --color=auto proxy.sh
[root@server1 ~]#

Ejecutando el comando ps al | grep proxy.sh, observamos como efectivamente la prioridad ha sido asignada correctamente

Obs: Es necesario ser root para poder utilizar  el comando nice

renice

Si uno o más procesos usan muchos recursos del sistema, Usted puede cambiar las prioridades de los mismos en vez de terminarlos. Solo basta con concer el PID del proceso y asignarte el numero de pririoda [19] para abajo

[root@server1 ~]# ps al
F UID PID PPID PRI NI VSZ RSS WCHAN STAT TTY TIME COMMAND
4 0 2229 1 35 -15 110036 808 n_tty_ SNs+ tty1 0:00 /sbin/agetty --noclear tty1 linux
4 0 10589 10584 20 0 123028 3596 n_tty_ Ss+ pts/0 0:00 -bash
4 0 20079 20075 20 0 123036 3608 n_tty_ Ss+ pts/1 0:00 -bash
4 0 20907 20903 20 0 123036 3508 wait Ss pts/2 0:00 -bash
0 0 21052 20907 20 0 148932 1420 - R+ pts/2 0:00 ps al
[root@server1 ~]#

Cambiaremos al PID 229, que Tiene un prioridad de -15

[root@server1 ~]# renice +20 2229
2229 (process ID) old priority -15, new priority 19
[root@server1 ~]#

Comprobamos

[root@server1 ~]# ps al | grep 2229
4     0  2229     1  39  19 110036   808 n_tty_ SNs+ tty1       0:00 /sbin/agetty --noclear tty1 linux
0     0 21175 20907  20   0 112668   924 pipe_w S+   pts/2      0:00 grep --color=auto 2229
[root@server1 ~]#

Efectivamente cambio la priopridad a 20 el PID 229

Si usted es SysAdmin, y ahi otros usuarios con privilegios corriendo muchos recursos del sistema, puede cambiar la prioridad de los procesos de dicho usuario con un unico comando

[root@rhel ~]# ps -ef |grep manu
root     25505   940  0 09:36 ?        00:00:00 sshd: manu [priv]
manu     25511 25505  0 09:36 ?        00:00:00 sshd: manu@pts/1
manu     25516 25511  0 09:36 pts/1    00:00:00 -bash
root     25685 25390  0 09:38 pts/0    00:00:00 grep --color=auto manu
[root@rhel ~]# renice +20 -u manu
1003 (user ID) old priority 0, new priority 19

Estos temas son muy Importantes.. ahora usted puede hacer uso de el, recuerda cualquier duda dejen sus comentarios

 

Leave a Reply

Your email address will not be published. Required fields are marked *