Guía para Maestría Avanzada de Comandos Linux Parte 2
En la Parte 1 de la serie, usted aprendió algunos comandos útiles no tan conocidos y algunos de los comandos comúnmente utilizados pero con parámetros no tan conocidos para hacer su trabajo de manera más eficiente. Para continuar con la serie, ahora aprenderá algunos comandos Linux más avanzados útiles para los usuarios Oracle, ya sean desarrolladores o DBAs.Alias y unalias
Supongamos que quiere verificar el grupo de variables del entorno ORACLE_SID de su shell. Deberá tipear:
echo $ORACLE_HOME
Como DBA o desarrollador, utiliza frecuentemente este comando y pronto se cansa de tipear los 16 caracteres. ¿Hay una manera más simple?
Sí: el comando alias. Con este enfoque, puede crear un breve alias, como "os", para representar todo el comando:
alias os='echo $ORACLE_HOME'
Ahora cuando quiera verificar ORACLE_SID, simplemente escriba "os" (sin comillas) y Linux ejecuta el comando con el alias.
No obstante, si se desconecta y se vuelve a conectar, el alias es eliminado y debe ingresar el comando alias nuevamente. Para eliminar este paso, todo lo que debe hacer es colocar el comando en su archivo de perfil shell. Para bash, el archivo es .bash_profile (note el punto antes del nombre de archivo, es parte del nombre de archivo) en su directorio de inicio. Para los shells bourne y korn, es .profile, y para c-shell, .chsrc.
Usted puede crear un alias para cualquier nombre. Por ejemplo, yo siempre creo un alias para el comando rm como rm -i, que hace que el comando rm sea interactivo.
alias rm=’rm -i’
Cuando emito un comando rm, Linux solicita mi confirmación, y a menos que agregue "y", no elimina el archivo—así quedo protegido ante la posibilidad de eliminar accidentalmente un archivo importante. Utilizo lo mismo para mv (para cambiar el archivo a otro nombre), lo cual evita la sobrescritura accidental de archivos existentes, y cp (para copiar el archivo).
A continuación, presentamos una lista de algunos alias muy útiles que quiero definir:
alias bdump='cd $ORACLE_BASE/admin/$ORACLE_SID/bdump' alias l='ls -d .* --color=tty' alias ll='ls -l --color=tty' alias mv='mv -i' alias oh='cd $ORACLE_HOME' alias os='echo $ORACLE_SID' alias rm='rm -i' alias tns='cd $ORACLE_HOME/network/admin'
Para ver qué alias han sido definidos en su shell, use alias sin ningún parámetro.
Sin embargo, hay un pequeño problema. He definido un alias, rm, que ejecuta rm -i. Este comando solicitará mi confirmación cada vez que intente eliminar un archivo. ¿Pero qué sucede si quiero eliminar muchos archivos y estoy seguro de que pueden eliminarse sin mi confirmación?
La solución es simple: Para suprimir el alias y utilizar solo el comando, necesitaré ingresar dos comillas simples:
$ ''rm *
Fíjese que se trata de dos comillas simples (') antes del comando rm, no dos comillas dobles. Esto suprimirá el alias rm. Otro enfoque es utilizar una barra inversa (\):
$ \rm *
Para eliminar un alias previamente definido, simplemente utilice el comando unalias:
$ unalias rm
ls
El comando ls es frecuentemente utilizado pero pocas veces es utilizado en su totalidad. Sin ninguna opción, ls despliega meramente todos los archivos y directorios en formato tabular.
$ ls
admin has mesg precomp
apex hs mgw racg
assistants install network rdbms
... output snipped ...
Para mostrarlos en una lista, use la opción -1 (el número 1, no la letra "l").$ ls -1
admin
apex
assistants
... output snipped ...
Esta opción es útil en shell scripts donde los nombres de archivo necesitan incorporarse en otro programa o comando para la manipulación.Seguramente, usted utilizó -l (la letra "l", no el número "1") que despliega todos los atributos de los archivos y directorios. Veámoslo una vez más:
$ ls -l total 272 drwxr-xr-x 3 oracle oinstall 4096 Sep 3 03:27 admin drwxr-x--- 7 oracle oinstall 4096 Sep 3 02:32 apex drwxr-x--- 7 oracle oinstall 4096 Sep 3 02:29 assistants
La primera columna muestra el tipo de archivo y los permisos sobre él: "d" significa directorio, "-" significa archivo regular, "c" significa un dispositivo de caracteres, "b" significa un dispositivo de bloques, "p" significa named pipe, y "l" (letra minúscula L, no I) significa enlace simbólico.
Una opción muy útil es --color, que muestra los archivos en muchos colores diferentes de acuerdo con el tipo de archivo. Aquí hay un ejemplo:
Fíjese que los archivos 1 y 2 son archivos comunes. link1 es un enlace simbólico, que se muestra en rojo; dir1 es un directorio y se muestra en amarillo; y pipe1 es un named pipe, y se muestra en diferentes colores para una identificación más fácil.
En algunos distros, el comando ls viene preinstalado con un alias (descripto en la sección anterior) como ls --color; de manera que usted pueda ver los archivos en color cuando tipea "ls". Este enfoque puede no ser aconsejable, especialmente si tiene un output como ese arriba. Puede cambiar los colores, pero una forma más rápida puede ser simplemente suspender el alias:
$ alias ls="''ls"
Otra opción útil es la opción -F, que añade un símbolo después de cada archivo para mostrar el tipo de archivo - una "/" después de los directorios, "@" después de enlaces simbólicos, y "|" después de named pipes.
$ ls -F dir1/ file1 file2 link1@ pipe1|
Si tiene un subdirectorio en un directorio y quiere hacer solo una lista de ese directorio, ls -l le mostrará los contenidos del subdirectorio también. Por ejemplo, supongamos que la estructura de directorio es la siguiente:
/dir1 +-->/subdir1 +--> subfile1 +--> subfile2
El directorio dir1 tiene un subdirectorio subdir1 y dos archivos: subfile1 y subfile2. Si solo desea ver los atributos del directorio dir1, emite:
$ ls -l dir1 total 4 drwxr-xr-x 2 oracle oinstall 4096 Oct 14 16:52 subdir1 -rw-r--r-- 1 oracle oinstall 0 Oct 14 16:48 subfile1 -rw-r--r-- 1 oracle oinstall 0 Oct 14 16:48 subfile2
Fíjese que el directorio dir1 no está en la lista del output. En cambio, se muestran los contenidos del directorio. Este es un comportamiento esperado cuando se procesan directorios. Para mostrar únicamente el directorio dir1, deberá utilizar el comando -d.
$ ls -dl dir1 drwxr-xr-x 3 oracle oinstall 4096 Oct 14 16:52 dir1
Vea el output del siguiente output ls -l:
-rwxr-x--x 1 oracle oinstall 10457761 Apr 6 2006 rmanO -rwxr-x--x 1 oracle oinstall 10457761 Sep 23 23:48 rman -rwsr-s--x 1 oracle oinstall 93300507 Apr 6 2006 oracleO -rwx------ 1 oracle oinstall 93300507 Sep 23 23:49 oracle
Notará que los tamaños de los archivos se muestran en bytes. Esto puede ser fácil en archivos pequeños, pero cuando el tamaño de los archivos es grande, puede no ser tan fácil leer un número largo. La opción "-h" es práctica aquí, para mostrar el tamaño de manera legible para personas.
$ ls -lh -rwxr-x--x 1 oracle oinstall 10M Apr 6 2006 rmanO -rwxr-x--x 1 oracle oinstall 10M Sep 23 23:48 rman -rwsr-s--x 1 oracle oinstall 89M Apr 6 2006 oracleO -rwx------ 1 oracle oinstall 89M Sep 23 23:49 oracle
Fíjese cómo se muestra el tamaño en M (para megabytes), K (para kilobytes), etc.
$ ls -lr
El parámetro -r muestra el output en orden inverso. En este comando, los archivos se mostrarán en orden alfabético inverso.
$ ls -lR
El operador -R hace que el comando ls se ejecute repetitivamente—es decir, explorar los subdirectorios y mostrar esos archivos también.
¿Qué sucede si quiere mostrar los archivos del más grande al más chico? Esto puede realizarse con el parámetro -S.
$ ls -lS total 308 -rw-r----- 1 oracle oinstall 52903 Oct 11 18:31 sqlnet.log -rwxr-xr-x 1 oracle oinstall 9530 Apr 6 2006 root.sh drwxr-xr-x 2 oracle oinstall 8192 Oct 11 18:14 bin drwxr-x--- 3 oracle oinstall 8192 Sep 23 23:49 lib
xargs
La mayoría de los comandos Linux tienen el fin de obtener un output: una lista de archivos, una lista de sucesiones, etc. ¿Pero qué sucede si quiere utilizar algún otro comando con el output del anterior como parámetro? Por ejemplo, el comando file muestra el tipo de archivo (ejecutable, texto ascii, etc.); puede manipular el output para que muestre solo los nombres de archivo y ahora quiere pasar estos nombres al comando ls -l para ver la fecha de registro. El comando xargs hace exactamente eso. Permite ejecutar algunos otros comandos en el output. Recuerde esta sintaxis de la Parte 1:
file -Lz * | grep ASCII | cut -d":" -f1 | xargs ls -ltr
Ahora, queremos utilizar el comando ls -l y pasar la lista de arriba como parámetros, uno a la vez. El comando xargs le permitió hacer eso. La última parte, xargs ls -ltr, toma el output y ejecuta el comando ls -ltr sobre ellos, como si ejecutase:
alert_DBA102.log: ASCII English text alert_DBA102.log.Z: ASCII text (compress'd data 16 bits) dba102_asmb_12307.trc.Z: ASCII English text (compress'd data 16 bits) dba102_asmb_20653.trc.Z: ASCII English text (compress'd data 16 bits)
xargs no es útil por sí mismo, pero es bastante bueno cuando se combina con otros comandos. Aquí se muestra otro ejemplo, donde queremos contaar la cantidad de líneas en esos archivos:
alert_DBA102.log alert_DBA102.log.Z dba102_asmb_12307.trc.Z dba102_asmb_20653.trc.Z
Ahora, queremos utilizar el comando ls -l y pasar la lista de arriba como parámetros, uno a la vez. El comando xargs le permitió hacer eso. La última parte, xargs ls -ltr, toma el output y ejecuta el comando ls -ltr sobre ellos, como si ejecutase:
ls -ltr alert_DBA102.log ls -ltr alert_DBA102.log.Z ls -ltr dba102_asmb_12307.trc.Z ls -ltr dba102_asmb_20653.trc.Z
xargs no es útil por sí mismo, pero es bastante bueno cuando se combina con otros comandos.
Aquí se muestra otro ejemplo, donde queremos contaar la cantidad de líneas en esos archivos:
$ file * | grep ASCII | cut -d":" -f1 | xargs wc -l
47853 alert_DBA102.log
19 dba102_cjq0_14493.trc
29053 dba102_mmnl_14497.trc
154 dba102_reco_14491.trc
43 dba102_rvwr_14518.trc
77122 total
(Nota: la tarea de arriba también puede lograrse con el siguiente comando:)
$ wc -l ‘file * | grep ASCII | cut -d":" -f1 | grep ASCII | cut -d":" -f1‘
La versión xargs está dada para ilustrar el concepto. Linux tiene varias maneras de lograr la misma tarea; use la que mejor se adapte a su situación.
Al utilizar este enfoque, usted puede rápidamente renombrar los archivos de un directorio.
$ ls | xargs -t -i mv {} {}.bak
La opción -i le comunica a xargs que reemplace {} con el nombre de cada elemento. La opción -t ordena a xargs que imprima el comando antes de ejecutarlo.
Otra operación es muy útil cuando quiere abrir los archivos para edición utilizando vi:
$ file * | grep ASCII | cut -d":" -f1 | xargs vi
Este comando abre los archivos uno por uno utilizando vi. Cuando quiere buscar muchos archivos y abrirlos para edición, esto resulta muy útil.
También tiene varias opciones. Tal vez la más útil es la opción -p, que hace que la operación sea interactiva:
$ file * | grep ASCII | cut -d":" -f1 | xargs -p vi
vi alert_DBA102.log dba102_cjq0_14493.trc dba102_mmnl_14497.trc
dba102_reco_14491.trc dba102_rvwr_14518.trc ?...
Aquí xarg le pide confirmación antes de ejecutar cada comando. Si presiona "y", ejecuta el comando. Le resultará extremadamente útil cuando realice algunas operaciones potencialmente perjudiciales e irreversibles en el archivo—como eliminar o sobrescribirlo.La opción -t utiliza un modo verboso; despliega el comando que está por ejecutar, la cual es una opción muy útil durante la depuración.
¿Qué sucede si el output pasara a xargs en blanco? Considere:
$ file * | grep SSSSSS | cut -d":" -f1 | xargs -t wc -l
wc -l
0
$
Aquí buscar "SSSSSS" no produce ninguna concordancia; entonces el input de xargs son todos espacios en blanco, como se muestra en la segunda línea (producida al utilizar la opción -t o verbosa). A pesar de que esto puede ser útil, en algunos casos usted puede querer detener xargs si no hay nada que procesar; si lo hay, puede utilizar la opción -r:
$ file * | grep SSSSSS | cut -d":" -f1 | xargs -t -r wc -l $El comando existe si no hay nada que ejecutar.
Supongamos que quiere eliminar los archivos utilizando el comando rm, que debería ser el argumento para el comando xargs. No obstante, rm puede aceptar una cantidad limitada de argumentos. ¿Qué sucede si su lista de argumentos excede ese límite? La opción -n para xargs limita la cantidad de argumentos en una sola línea de comando.
Aquí mostramos cómo puede limitar solo dos argumentos por línea de comando: Incluso si cinco líneas pasan a xargs ls -ltr, solo dos archivos pasan a ls -ltr por vez.
$ file * | grep ASCII | cut -d":" -f1 | xargs -t -n2 ls -ltr ls -ltr alert_DBA102.log dba102_cjq0_14493.trc -rw-r----- 1 oracle dba 738 Aug 10 19:18 dba102_cjq0_14493.trc -rw-r--r-- 1 oracle dba 2410225 Aug 13 05:31 alert_DBA102.log ls -ltr dba102_mmnl_14497.trc dba102_reco_14491.trc -rw-r----- 1 oracle dba 5386163 Aug 10 17:55 dba102_mmnl_14497.trc -rw-r----- 1 oracle dba 6808 Aug 13 05:21 dba102_reco_14491.trc ls -ltr dba102_rvwr_14518.trc -rw-r----- 1 oracle dba 2087 Aug 10 04:30 dba102_rvwr_14518.trc
Utilizando este enfoque, usted puede rápidamente renombrar los archivos de un directorio.
$ ls | xargs -t -i mv {} {}.bak
La opción -i le comunica a xargs que reemplace {} con el nombre de cada elemento.
rename
Como sabe, el comando mv renombra los archivos. Por ejemplo,
$ mv oldname newnameoldnamenewnamerename
rename .log .log.‘date +%F-%H:%M:%S‘ *
reemplaza todos los archivos con la extensión .log por .log.
find
Ente los usuarios Oracle, el más conocido es el comando find. Hasta ahora, sabe cómo utilizar find para buscar archivos en un directorio determinado. Aquí mostramos un ejemplo que comienza con la palabra "file" en el directorio actual:
$ find . -name "file*" ./file2 ./file1 ./file3 ./file4
No obstante, ¿qué sucede si quiere buscar nombres como FILE1, FILE2, etc.? -name "file*" no tendrá concordancia. Para una búsqueda con distinción de mayúsculas y minúsculas, use la opción -iname:
$ find . -iname "file*" ./file2 ./file1 ./file3 ./file4 ./FILE1 ./FILE2
Puede restringir su búsqueda a un tipo específico de archivos. Por ejemplo, el comando de arriba obtendrá archivos de todo tipo: archivos comunes, directorios, enlaces simbólicos, etc. Para buscar solo archivos comunes, puede utilizar el parámetro -type f.
$ find . -name "orapw*" -type f ./orapw+ASM ./orapwDBA102 ./orapwRMANTEST ./orapwRMANDUP ./orapwTESTAUX
-type puede tomar los modificadores f (para archivos comunes), l (para enlaces simbólicos), d (directorios), b (dispositivos de bloque), p (named pipes), c (dispositivos de caracteres), s (sockets).
Un pequeño cambio en el comando de arriba es combinarlo con el comando file que conoció en la Parte 1. El comando file le dice qué tipo de archivo es. Puede transmitirlo como post procesador para el output desde el comando find. El parámetro -exec ejecuta el comando que sigue el parámetro. En este caso, el comando a ejecutar después de find es file:
$ find . -name "*oraenv*" -type f -exec file {} \;
./coraenv: Bourne shell script text executable
./oraenv: Bourne shell script text executable
Esto es útil cuando quiere descubrir si el archivo de texto ASCII podría ser algún tipo de shell script.
Si sustituye -exec con -ok, el comando es ejecutado pero solicita confirmación primero. Aquí hay un ejemplo:
$ find . -name "sqlplus*" -ok {} \;
< {} ... ./sqlplus > ? y
SQL*Plus: Release 9.2.0.5.0 - Production on Sun Aug 6 11:28:15 2006
Copyright (c) 1982, 2002, Oracle Corporation. All rights reserved.
Enter user-name: / as sysdba
Connected to:
Oracle9i Enterprise Edition Release 9.2.0.5.0 - 64bit Production
With the Partitioning,Real Application Clusters,OLAP
and Oracle Data Mining options
JServer Release 9.2.0.5.0 - Production
SQL> exit
Disconnected from Oracle9i Enterprise Edition Release 9.2.0.5.0-64bit Production
With the Partitioning,Real Application Clusters,OLAP
and Oracle Data Mining options
JServer Release 9.2.0.5.0 - Production
< È* ... ./sqlplusO > ? n
$
Aquí, hemos pedido al shell que busque todos los programas que comienzan con "sqlplus", y que los ejecute. Fíjese que no hay nada entre -ok y {}, por lo tanto solo ejecutará los archivos que encuentre. Encuentra dos archivos—sqlplus y sqlplusO—y en ambos casos pregunta si usted desea ejecutarlos. Respondemos "y" para el prompt de "sqlplus" y lo ejecuta. Después de salir, solicita el segundo archivo que encontró (sqlplusO) y solicita confirmación una y otra vez, a lo cual respondimos "n"—entonces, no se ejecutó.
Consejo para Usuarios Oracle
Oracle produce varios archivos extraños: archivos de localización, archivos testigo, archivos dump, etc. A menos que se limpien periódicamente, pueden llenar el sistema de archivos e interrumpir la base de datos.
Para garantizar que eso no suceda, simplemente busque los archivos con extensión "trc" y elimínelos si tienen más de tres días de antigüedad. Un comando simple es la solución:
find . -name "*.trc" -ctime +3 -exec rm {} \;
Para eliminarlos antes del límite de tres días, use la opción -f.
find . -name "*.trc" -ctime +3 -exec rm -f {} \;
Si simplemente desea enumerar los archivos:
find . -name "*.trc" -ctime +3 -exec ls -l {} \;
m4
Este comando toma un archivo input y sustituye las cadenas dentro de él con los parámetros transmitidos, lo cual es similar a sustituirlas por variables. Por ejemplo, vea un archivo input:
$ cat temp The COLOR fox jumped over the TYPE fence.
Si quiere sustituir las cadenas "COLOR" por "brown" y "TYPE" por "broken", puede utilizar:
$ m4 -DCOLOR=brown -DTYPE=broken temp The brown fox jumped over the broken fence. Else, if you want to substitute "white" and "high" for the same: $ m4 -DCOLOR=white -DTYPE=high temp The white fox jumped over the high fence.
whence y which
Estos comandos son utilizados para saber dónde se almacenan los ejecutables mencionados en el PROCESO del usuario. Cuando el ejecutable es encontrado en el proceso, se comportan de manera bastante similar y muestran el proceso:
$ which sqlplus
/u02/app/oracle/products/10.2.0.1/db1/bin/sqlplus
$ whence sqlplus
/u02/app/oracle/products/10.2.0.1/db1/bin/sqlplus
El output es idéntico. Sin embargo, si el ejecutable no es encontrado en el proceso, el comportamiento es diferente. El comando which produce un mensaje explícito:$ which sqlplus1
/usr/bin/which: no sqlplus1 in (/u02/app/oracle/products/10.2.0.1/db1/bin:/usr
/kerberos/bin:/usr/local/bin:/bin:/usr/bin:/usr/X11R6/bin)
whereas El comando whence no produce mensaje:$ whence sqlplus1]
y vuelve a shell prompt. Esto es útil en casos donde el ejecutable no es encontrado en el proceso (en lugar de mostrar el mensaje):
$ whence invalid_command
$ which invalid_command
which: no invalid_command in (/usr/kerberos/sbin:/usr/kerberos/bin:/bin:/sbin:
/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:
/usr/bin/X11:/usr/X11R6/bin:/root/bin)
Cuando whence no encuentra un ejecutable en el proceso, vuelve sin ningún mensaje pero el código de retorno no es cero. Esto puede utilizarse en shell scripts; por ejemplo:RC=‘whence myexec‘ If [ $RC -ne "0" ]; then echo "myexec is not in the $PATH" fi
Una opción muy útil es la opción -i, que muestra el alias y el ejecutable, si está presente. Por ejemplo, usted pudo ver el uso del alias al comienzo de este artículo. El comando rm es en realidad un alias en mi shell, y también en cualquier lugar donde haya un comando rm en el sistema.
$ which ls /bin/ls $ which -i ls alias ls='ls --color=tty' /bin/ls
El comportamiento por defecto es mostrar la primera ocurrencia del ejecutable en el proceso. Si el ejecutable existe en diferentes directorios del proceso, las ocurrencias subsiguientes son ignoradas. Puede ver todas las ocurrencias del ejecutable mediante la opción -a.$ which java /usr/bin/java $ which -a java /usr/bin/java /home/oracle/oracle/product/11.1/db_1/jdk/jre/bin/java
top
El comando top es probablemente el más útil para un Oracle DBA que administra una base de datos sobre Linux. Digamos que el sistema es lento y quiere saber quién está saturando la CPU y/o memoria. Para mostrar los procesos clave, utiliza el comando top.
Fíjese que a diferencia de otros comandos, top no produce un output y permanece inactivo. Actualiza la pantalla para mostrar nueva información. Por lo tanto, si simplemente activa top y deja la pantalla activa, siempre contará con la información más actual. Para cancelar e ir hacia shell, puede presionar Control-C.
$ top
18:46:13 up 11 days, 21:50, 5 users, load average: 0.11, 0.19, 0.18
151 processes: 147 sleeping, 4 running, 0 zombie, 0 stopped
CPU states: cpu user nice system irq softirq iowait idle
total 12.5% 0.0% 6.7% 0.0% 0.0% 5.3% 75.2%
Mem: 1026912k av, 999548k used, 27364k free, 0k shrd, 116104k buff
758312k actv, 145904k in_d, 16192k in_c
Swap: 2041192k av, 122224k used, 1918968k free 590140k cached
PID USER PRI NI SIZE RSS SHARE STAT %CPU %MEM TIME CPU COMMAND
451 oracle 15 0 6044 4928 4216 S 0.1 0.4 0:20 0 tnslsnr
8991 oracle 15 0 1248 1248 896 R 0.1 0.1 0:00 0 top
1 root 19 0 440 400 372 S 0.0 0.0 0:04 0 init
2 root 15 0 0 0 0 SW 0.0 0.0 0:00 0 keventd
3 root 15 0 0 0 0 SW 0.0 0.0 0:00 0 kapmd
4 root 34 19 0 0 0 SWN 0.0 0.0 0:00 0 ksoftirqd/0
7 root 15 0 0 0 0 SW 0.0 0.0 0:01 0 bdflush
5 root 15 0 0 0 0 SW 0.0 0.0 0:33 0 kswapd
6 root 15 0 0 0 0 SW 0.0 0.0 0:14 0 kscand
8 root 15 0 0 0 0 SW 0.0 0.0 0:00 0 kupdated
9 root 25 0 0 0 0 SW 0.0 0.0 0:00 0 mdrecoveryd
... output snipped ...
Examinemos los diferentes tipos de información producidos. La primera línea:18:46:13 up 11 days, 21:50, 5 users, load average: 0.11, 0.19, 0.18
muestra la hora actual (18:46:13), que el sistema ha estado activo durante 11 días; que el sistema ha trabajado durante 21 horas 50 segundos. Se muestra el promedio de carga del sistema (0.11, 0.19, 0.18) para los últimos 1, 5 y 15 minutos respectivamente. (A propósito, usted también puede obtener esta información ejecutando el uptime command.)
Si el promedio de carga no es necesario, presione la letra "l" (L minúscula); lo desactivará. Para volver a activarlo presione l nuevamente. La segunda línea:
151 processes: 147 sleeping, 4 running, 0 zombie, 0 stopped
muestra la cantidad de procesos, en ejecución, inactivos, etc. La tercera y cuarta línea:
CPU states: cpu user nice system irq softirq iowait idle
total 12.5% 0.0% 6.7% 0.0% 0.0% 5.3% 75.2%
muestran los detalles del uso de CPU. La línea de arriba muestra que los procesos de los usuarios consumen un 12,5% y el sistema consume un 6,7%. Los procesos del usuario incluyen los procesos Oracle. Presione "t" para activar y desactivar estas tres líneas. Si hay más de una CPU, usted verá una línea por CPU.
Las próximas dos líneas:
Mem: 1026912k av, 1000688k used, 26224k free, 0k shrd, 113624k buff
758668k actv, 146872k in_d, 14460k in_c
Swap: 2041192k av, 122476k used, 1918716k free 591776k cached
muestran la memoria disponible y utilizada. La memoria total es "1026912k av", aproximadamente 1GB, de la cual solo 26224k o 26MB está libre. El espacio de intercambio es de 2GB; pero casi no es utilizado. Para activarlo y desactivarlo, presione "m".
El resto muestra los procesos en un formato tabular. A continuación, se explican las columnas:
| Columna | Descripción |
| PID | El ID del proceso |
| USER | El usuario que ejecuta el proceso |
| PRI | La prioridad del proceso |
| NI | El valor nice: Cuanto más alto es el valor, más baja es la prioridad de la tarea |
| SIZE | Memoria utilizada por este proceso (código+datos+stack) |
| RSS | Memoria física utilizada por este proceso |
| SHARE | Memoria compartida utilizada por este proceso |
| STAT | El estado de este proceso, mostrado en códigos. Algunos códigos importantes de estado son: R – Running (enejecución) S –Sleeping (inactivo) Z – Zombie (vacilante) T – Stopped (detenido) Usted también puede ver el segundo y tercer carácter, que indican: W – Swapped out process (proceso intercambiado) N – positive nice value (valor nice positivo) |
| %CPU | Porcentaje de CPU utilizado por este proceso |
| %MEM | Porcentaje de memoria utilizado por este proceso |
| TIME | Tiempo total de CPU utilizado por este proceso |
| CPU | Si este es un proceso de procesadores múltiples, esta columna indica el ID de la CPU sobre la cual se está ejecutando este proceso. |
| COMMAND | Comando utilizado por este proceso |
Mientras se muestra top, puede presionar algunas teclas para formatear la representación visual como usted quiera. Presionar la tecla mayúscula M clasifica el output por uso de memoria. (Fíjese que utilizar la letra minúscula m activará o desactivará las líneas de resumen de memoria en la parte superior de la representación visual). Esto es muy útil cuando quiere descubrir quién consume la memoria. Vea un ejemplo de output:
PID USER PRI NI SIZE RSS SHARE STAT %CPU %MEM TIME CPU COMMAND 31903 oracle 15 0 75760 72M 72508 S 0.0 7.2 0:01 0 ora_smon_PRODB2 31909 oracle 15 0 68944 66M 64572 S 0.0 6.6 0:03 0 ora_mmon_PRODB2 31897 oracle 15 0 53788 49M 48652 S 0.0 4.9 0:00 0 ora_dbw0_PRODB2
Ahora que ya sabe cómo interpretar el output, veamos cómo utilizar los parámetros de línea de comando.
El más útil es -d, que indica la demora entre las actualizaciones de pantalla. Para actualizar cada segundo, use top -d 1.
La otra opción útil es -p. Si solo desea monitorear algunos procesos, no todos, puede especificar solo aquellos después de la opción -p. Para monitorear los procesos 13609, 13608 y 13554:
top -p 13609 -p 13608 -p 13554
Esto mostrará los resultados en el mismo formato que el comando top, pero solo esos procesos específicos.
Consejo para Usuarios Oracle
Es casi innecesario decir que top resulta muy útil para analizar el desempeño de los servidores de base de datos. Aquí mostramos un output top parcial.
20:51:14 up 11 days, 23:55, 4 users, load average: 0.88, 0.39, 0.27
113 processes: 110 sleeping, 2 running, 1 zombie, 0 stopped
CPU states: cpu user nice system irq softirq iowait idle
total 1.0% 0.0% 5.6% 2.2% 0.0% 91.2% 0.0%
Mem: 1026912k av, 1008832k used, 18080k free, 0k shrd, 30064k buff
771512k actv, 141348k in_d, 13308k in_c
Swap: 2041192k av, 66776k used, 1974416k free 812652k cached
PID USER PRI NI SIZE RSS SHARE STAT %CPU %MEM TIME CPU COMMAND
16143 oracle 15 0 39280 32M 26608 D 4.0 3.2 0:02 0 oraclePRODB2...
5 root 15 0 0 0 0 SW 1.6 0.0 0:33 0 kswapd
... output snipped ...
Analicemos el output cuidadosamente. Lo primero que debería notar es que la columna "inactiva" de la CPU indica; 0,0%—es decir, la CPU está completamente ocupada haciendo algo. La pregunta es, ¿haciendo qué? Preste atención a la columna "sistema", ligeramente a la izquierda; muestra 5,6%. Entonces el sistema no está haciendo mucho. Vaya más a la izquierda hasta la columna "usuario", que muestra 1,0%. Como los procesos de usuarios incluyen Oracle también, Oracle no consume los ciclos de CPU. Por lo tanto, ¿qué consume toda la CPU?La respuesta está en la misma línea, justo a la derecha en la columna "iowait", que indica un 91,2%. Esto lo explica todo: la CPU está esperando IO el 91,2% del tiempo.
¿Entonces, por qué tanta espera por IO? La respuesta está en la pantalla. Fíjese en el PID del proceso con mayor consumo: 16143. Puede utilizar la siguiente consulta para determinar qué está haciendo el proceso:
select s.sid, s.username, s.program
from v$session s, v$process p
where spid = 16143
and p.addr = s.paddr
/
SID USERNAME PROGRAM
------------------- -----------------------------
159 SYS rman@prolin2 (TNS V1-V3)
El proceso rman está reduciendo los ciclos de CPU relacionados con la espera de IO. Esta información ayuda a determinar el próximo plan de acción.
skill y snice
En el debate anterior, aprendió cómo identificar un recurso de consumo de CPU. ¿Qué sucede si descubre que un proceso consume mucha CPU y memoria, pero no quiere cancelarlo? Considere este output top:
$ top -c -p 16514
23:00:44 up 12 days, 2:04, 4 users, load average: 0.47, 0.35, 0.31
1 processes: 1 sleeping, 0 running, 0 zombie, 0 stopped
CPU states: cpu user nice system irq softirq iowait idle
total 0.0% 0.6% 8.7% 2.2% 0.0% 88.3% 0.0%
Mem: 1026912k av, 1010476k used, 16436k free, 0k shrd, 52128k buff
766724k actv, 143128k in_d, 14264k in_c
Swap: 2041192k av, 83160k used, 1958032k free 799432k cached
PID USER PRI NI SIZE RSS SHARE STAT %CPU %MEM TIME CPU COMMAND
16514 oracle 19 4 28796 26M 20252 D N 7.0 2.5 0:03 0 oraclePRODB2...
Ahora que confirmó que el proceso 16514 consume mucha memoria, puede "congelarlo"—pero no cancelarlo—usando el comando skill.
$ skill -STOP 1
Luego, vea el output top:
23:01:11 up 12 days, 2:05, 4 users, load average: 1.20, 0.54, 0.38
1 processes: 0 sleeping, 0 running, 0 zombie, 1 stopped
CPU states: cpu user nice system irq softirq iowait idle
total 2.3% 0.0% 0.3% 0.0% 0.0% 2.3% 94.8%
Mem: 1026912k av, 1008756k used, 18156k free, 0k shrd, 3976k buff
770024k actv, 143496k in_d, 12876k in_c
Swap: 2041192k av, 83152k used, 1958040k free 851200k cached
PID USER PRI NI SIZE RSS SHARE STAT %CPU %MEM TIME CPU COMMAND
16514 oracle 19 4 28796 26M 20252 T N 0.0 2.5 0:04 0 oraclePRODB2...
La CPU ahora está un 94% inactiva, de 0%. El proceso queda efectivamente congelado. Después de algún tiempo, puede querer reanudar el proceso del coma:
$ skill -CONT 16514
Este enfoque es muy útil para congelar temporalmente los procesos a fin de hacer lugar para finalizar los procesos más importantes.
El comando es muy versátil. Si desea detener todos los procesos de usuario "oracle", hay únicamente un solo comando que lo hace todo:
$ skill -STOP oracle
Puede utilizar un usuario, PID, un comando o terminal id como argumento. Lo que se muestra a continuación detiene todos los comandos rman.
$ skill -STOP rman
Como puede ver, skill decide ese argumento que ingresó—un ID para el proceso, un id de usuario o un comando—y actúa en consecuencia. Esto puede causar problemas en algunos casos, donde puede tener un usuario y un comando con el mismo nombre. El mejor ejemplo es el proceso "oracle", que en general es ejecutado por el usuario "oracle". Por lo tanto, cuando quiere detener el proceso denominado "oracle" y realiza:
$ skill -STOP oracle
todos los procesos del usuario "oracle" se detienen, incluso la sesión que puede estar ejecutando en ese momento. Para ser completamente ambiguo, puede opcionalmente ofrecer un nuevo parámetro para especificar el tipo de parámetro. Para detener un comando llamado oracle, puede:
$ skill -STOP -c oracle
El comando snice es similar. En lugar de detener un proceso, hace que su prioridad sea más baja. Primero, vea el output:
PID USER PRI NI SIZE RSS SHARE STAT %CPU %MEM TIME CPU COMMAND
3 root 15 0 0 0 0 RW 0.0 0.0 0:00 0 kapmd
13680 oracle 15 0 11336 10M 8820 T 0.0 1.0 0:00 0 oracle
13683 oracle 15 0 9972 9608 7788 T 0.0 0.9 0:00 0 oracle
13686 oracle 15 0 9860 9496 7676 T 0.0 0.9 0:00 0 oracle
13689 oracle 15 0 10004 9640 7820 T 0.0 0.9 0:00 0 oracle
13695 oracle 15 0 9984 9620 7800 T 0.0 0.9 0:00 0 oracle
13698 oracle 15 0 10064 9700 7884 T 0.0 0.9 0:00 0 oracle
13701 oracle 15 0 22204 21M 16940 T 0.0 2.1 0:00 0 oracle
Ahora, reduzca cuatro puntos la prioridad de los procesos de "oracle". Fíjese que cuanto mayor es el número, más baja es la prioridad.
$ snice +4 -u oracle PID USER PRI NI SIZE RSS SHARE STAT %CPU %MEM TIME CPU COMMAND 16894 oracle 20 4 38904 32M 26248 D N 5.5 3.2 0:01 0 oracle
Note cómo la columna NI (para valores nice) ahora es 4 y la prioridad está ahora fijada en 20, en lugar de 15. Esto es bastante útil para reducir prioridades.
Cómo puedo borrar lo que hay en caché
sudo su
sync && echo 3 > /proc/sys/vm/drop_caches
exit
