59298441 Comandos Linux Oracle

Guía para Maestría Avanzada de Comandos Linux

por Arup Nanda

Publicado en agosto de 2006

En el excelente artículo de Sheryl Calish, denominado “Guía para Maestría en Comandos de Archivos Linux", usted conoció algunos comandos Linux de rutina, que son especialmente valiosos para principiantes Linux. Pero ahora que conoce los puntos básicos, prosigamos con algunos comandos más sofisticados que encontrará extremadamente útiles.

En esta serie de cuatro partes, conocerá algunos trucos no tan conocidos sobre varios comandos de rutina, así como las variaciones en uso que los hacen más útiles. A medida que la serie avanza, conocerá comandos cada vez más difíciles de dominar.

Tenga en cuenta que estos comandos pueden diferir de acuerdo con la versión específica de Linux que utilice o qué kernel específica se compila, pero en ese caso, probablemente solo sea una diferencia mínima.

Cambios Sencillos a Propietarios, Grupos y Permisos En el artículo de Sheryl, usted aprendió cómo utilizar los comandos chown y chgrp para cambiar la propiedad y el grupo de los archivos. Supongamos que tiene varios archivos como este:

# ls -ltotal 8-rw-r--r-- 1 ananda users 70 Aug 4 04:02 file1-rwxr-xr-x 1 oracle dba 132 Aug 4 04:02 file2-rwxr-xr-x 1 oracle dba 132 Aug 4 04:02 file3-rwxr-xr-x 1 oracle dba 132 Aug 4 04:02 file4-rwxr-xr-x 1 oracle dba 132 Aug 4 04:02 file5-rwxr-xr-x 1 oracle dba 132 Aug 4 04:02 file6

y necesita cambiar los permisos de todos los archivos para asociar aquellos del archivo 1. Seguramente podría utilizar chmod 644 * para realizar ese cambio— ¿pero qué sucede si está escribiendo un script para hacerlo y no sabe cuáles son los permisos de antemano? O, tal vez esté hacienda varios cambios de permiso basados en muchos archivos diferentes y cree que no es factible examinar los permisos de cada uno y modificarlos en consecuencia.

Un mejor enfoque es hacer que los permisos sean similares a aquellos de otro archivo. Este comando hace que los permisos del archivo 2 sean los mismos que el archivo 1:

chmod --reference file1 file2

Ahora, si verifica:

# ls -l file[12]total 8-rw-r--r-- 1 ananda users 70 Aug 4 04:02 file1-rw-r--r-- 1 oracle dba 132 Aug 4 04:02 file2

Los permisos del archivo 2 fueron cambiados exactamente como el archivo 1. No necesitó obtener primero los permisos del archivo 1.

Usted también puede utilizar el mismo truco para la membresía de grupos en los archivos. Para que

http://www.oracle.com/technology/pub/articles/calish_file_commands.html

http://www.oracle.com/technology/pub/articles/calish_file_commands.html

el grupo del archivo 2 sea el mismo que el archivo 1, usted manifestaría:

# chgrp --reference file1 file2# ls -l file[12]-rw-r--r-- 1 ananda users 70 Aug 4 04:02 file1-rw-r--r-- 1 oracle users 132 Aug 4 04:02 file2

Desde luego, lo que funciona para el cambio de grupos funcionará para el propietario también. A continuación, mostramos cómo puede utilizar el mismo truco para un cambio de propiedad. Si los permisos son así:

# ls -l file[12] -rw-r--r-- 1 ananda users 70 Aug 4 04:02 file1-rw-r--r-- 1 oracle dba 132 Aug 4 04:02 file2

Usted puede cambiar la propiedad así:

# chown --reference file1 file2# ls -l file[12] -rw-r--r-- 1 ananda users 70 Aug 4 04:02 file1-rw-r--r-- 1 ananda users 132 Aug 4 04:02 file2

Fíjese que el grupo, y el propietario, han cambiado.

Consejo para Usuarios Oracle

Este es un truco que puede utilizar para cambiar la propiedad y los permisos de los ejecutables de Oracle en un directorio basado en un ejecutable de referencia. Esto es especialmente útil en migraciones donde puede (y probablemente deba) instalar un usuario diferente y luego trasladarlo a su propietario de software Oracle usual.

Más sobre Archivos El comando ls, con su gran cantidad de argumentos, brinda información muy útil sobre los archivos. Un comando diferente y menos conocido – stat – ofrece información incluso más útil. .

Aquí le mostramos cómo puede utilizarlo en el ejecutable “oracle”, que puede encontrarse en $ORACLE_HOME/bin.

# cd $ORACLE_HOME/bin# stat oracle File: `oracle' Size: 93300148 Blocks: 182424 IO Block: 4096 Regular FileDevice: 343h/835d Inode: 12009652 Links: 1 Access: (6751/-rwsr-s--x) Uid: ( 500/ oracle) Gid: ( 500/ dba)Access: 2006-08-04 04:30:52.000000000 -0400Modify: 2005-11-02 11:49:47.000000000 -0500Change: 2005-11-02 11:55:24.000000000 -0500

Fíjese la información que obtuvo con este comando: Además del tamaño de archivo usual (que puede obtener de ls -l), usted obtuvo la cantidad de bloques que ocupa este archivo. El tamaño de bloque Linux típico es de 512 bytes, entonces un archivo de 93.300.148 bytes ocuparía (93300148/512=) 182226.85 bloques. Como los bloques se utilizan en su totalidad, este archivo utiliza un número entero de bloques. En lugar de hacer conjeturas, usted puede saber cuáles son los bloques exactos.

Del output de arriba, usted también puede conocer el GID y UID de la propiedad del archivo y la representación octal de los permisos (6751). Si desea readmitir los mismos permisos que tiene ahora, puede utilizar chmod 6751 oracle en lugar de detallar explícitamente los permisos.

La parte más útil del output de arriba es la información de la fecha de registro del acceso al archivo. Muestra que se accedió al archivo el 04-08-2006 a las 04:30:52 (como se muestra al lado de “Acceso:”), o el 4 de agosto de 2006 a las 4:30:52 AM. Este es el momento en el cual se empezó a utilizar la base de datos. El archivo fue modificado el 02-11-2005 a las 11:49:47 (como se muestra al lado de Modificar:). Finalmente, la fecha de registro al lado de “Cambiar:” muestra cuándo fue cambiado el estado del archivo.

-f, un modificador del comando stat, muestra la información del sistema de archivo en lugar del archivo:

# stat -f oracle File: "oracle" ID: 0 Namelen: 255 Type: ext2/ext3Blocks: Total: 24033242 Free: 15419301 Available: 14198462 Size: 4096Inodes: Total: 12222464 Free: 12093976

Otra opción, -t, brinda exactamente la misma información pero en una sola línea:

# stat -t oracle oracle 93300148 182424 8de9 500 500 343 12009652 1 0 0 1154682061 1130950187 1130950524 4096

Esto es muy útil en shell scripts donde un simple comando de corte puede utilizarse para extraer los valores para el posterior procesamiento.


Cuando usted se vuelve a conectar con Oracle (a menudo se realiza durante la instalación de parches), los ejecutables existentes pasan a un nombre diferente antes de crear el nuevo. Por ejemplo, puede reconectar todos los servicios por

relink utilities

Recopila, entre otras cosas, el ejecutable sqlplus. Mueve el ejecutable existente sqlplus a sqlplusO. Si la recopilación falla por algún motivo, el proceso de reconexión vuelve a nombrar sqlplusO con sqlplus, y los cambios quedan anulados. De manera similar, si descubre un problema de funcionalidad después de aplicar un parche, puede rápidamente anular el parche al renombrar el archivo por su propia cuenta.

A continuación, mostramos cómo puede utilizar stat en estos archivos:

# stat sqlplus* File: 'sqlplus' Size: 9865 Blocks: 26 IO Block: 4096 Regular FileDevice: 343h/835d Inode: 9126079 Links: 1 Access: (0751/-rwxr-x--x) Uid: ( 500/ oracle) Gid: ( 500/ dba)Access: 2006-08-04 05:15:18.000000000 -0400Modify: 2006-08-04 05:15:18.000000000 -0400Change: 2006-08-04 05:15:18.000000000 -0400 File: 'sqlplusO' Size: 8851 Blocks: 24 IO Block: 4096 Regular FileDevice: 343h/835d Inode: 9125991 Links: 1 Access: (0751/-rwxr-x--x) Uid: ( 500/ oracle) Gid: ( 500/ dba)Access: 2006-08-04 05:13:57.000000000 -0400Modify: 2005-11-02 11:50:46.000000000 -0500Change: 2005-11-02 11:55:24.000000000 -0500

Muestra que sqlplusO fue modificado el 11 de noviembre d e2005, cuando sqlplus fue modificado el 4 de agosto de 2006, que también corresponde al tiempo de cambio de estado de sqlplusO. Indica

que la versión original de sqlplus estuvo vigente desde el 11 de noviembre de 2005 hasta el 4 de agosto de 2006. Si quiere diagnosticar algunos problemas de funcionalidad, este es un buen lugar para empezar. Además de los cambios de archivo, como usted conoce el horario de cambio de los permisos, usted puede correlacionarlo con cualquier problema de funcionalidad percibido.

Otro output importante es el tamaño del archivo, que es diferente—9865 bytes para sqlplus y 8851 para sqlplusO—e indica que las versiones no son meras compilaciones; en realidad cambiaron con bibliotecas adicionales (tal vez). Esto también indica la causa potencial de algunos problemas.

Tipos de Archivo Cuando ve un archivo, ¿cómo sabe qué tipo de archivo es? El comando file le da esa información. Por ejemplo:

# file alert_DBA102.logalert_DBA102.log: ASCII text

El archivo alert_DBA102.log es un archivo de texto ASCII. Veamos algunos ejemplos más:

# file initTESTAUX.ora.ZinitTESTAUX.ora.Z: compress'd data 16 bits

Esto demuestra que el archivo es un archivo comprimido, ¿pero cómo sabe qué tipo de archivo fue comprimido? Una opción es descomprimirlo y ejecutar el archivo; pero eso haría que sea virtualmente imposible. Una mejor opción es utilizar el parámetro -z:

# file -z initTESTAUX.ora.ZinitTESTAUX.ora.Z: ASCII text (compress'd data 16 bits)

Otra peculiaridad es la presencia de enlaces simbólicos:

# file spfile+ASM.ora.ORIGINAL spfile+ASM.ora.ORIGINAL: symbolic link to /u02/app/oracle/admin/DBA102/pfile/spfile+ASM.ora.ORIGINAL

Esto es útil; ¿pero qué tipo de archivo es al que se apunta? En lugar de ejecutar el archivo otra vez, puede utilizar la opción -l:

# file -L spfile+ASM.ora.ORIGINALspfile+ASM.ora.ORIGINAL: data

Esto demuestra claramente que el archivo es un archivo de datos. Tenga en cuenta que spfile es binario, a diferencia de init.ora; por lo tanto el archivo se muestra como archivo de datos.


Supongamos que está buscando un archivo de localización en el directorio de destino de descargas del usuario pero no está seguro de que el archivo esté ubicado allí o en otro directorio, y meramente está allí como enlace simbólico, o si alguien ha comprimido el archivo (o incluso lo ha renombrado). Hay algo que sí sabe: es definitivamente un archivo ascii. ¿Qué puede hacer?

file -Lz * | grep ASCII | cut -d":" -f1 | xargs ls -ltr

Este comando verifica los archivos ASCII, incluso si están comprimidos, y los enumera en orden cronológico.

Comparar Archivos ¿Cómo descubre si dos archivos—archivo1 y archivo2—son idénticos? Hay varias formas, y cada enfoque tiene su propio atractivo.

diff. El comando más simple es diff, que muestra la diferencia entre dos archivos. Vea los contenidos de dos archivos

# cat file1In file1 onlyIn file1 and file2# cat file2In file1 and file2In file2 only

Si utiliza el comando diff, podrá ver la diferencia entre los archivos, como se muestra abajo:

# diff file1 file21d0< In file1 only2a2> In file2 only#

En el output, un "<" en la primera columna indica que la línea existe en el archivo mencionado primero, —es decir, archivo1. Un ">" en ese lugar indica que la línea existe en el segundo archivo (archivo2). Los caracteres 1d0 de la primera línea del output muestra lo que debe hacerse en sed para operar en el archivo 1 para hacerlo idéntico al archivo 2.

Otra opción, -y, muestra el mismo output, pero uno al lado del otro:

# diff -y file1 file2 -W 120In file1 only <In file1 and file2 In file1 and file2 > In file2 only

La opción -W es opcional; simplemente ordena al comando utilizar una pantalla que permita 120 caracteres, útil para archivos con líneas largas.

Si solo desea saber si los archivos son diferentes, no necesariamente en qué difieren, puede utilizar la opción -q.

# diff -q file3 file4# diff -q file3 file2Files file3 and file2 differ

Los archivos 3 y 4 son los mismos, con lo cual no hay output; caso contrario, se informa si los archivos difieran.

Si está escribiendo un shell script, puede resultar útil generar el output de tal manera que pueda analizarse. La opción -u hace eso:

# diff -u file1 file2 --- file1 2006-08-04 08:29:37.000000000 -0400+++ file2 2006-08-04 08:29:42.000000000 -0400@@ -1,2 +1,2 @@-In file1 only In file1 and file2+In file2 only

El output muestra contenidos de ambos archivos pero suprime los duplicados, los signos + y – de la

primera columna indican las líneas de los archivos. Ningún carácter en la primera columna indica su presencia en ambos archivos.

El comando tiene en cuenta el espacio en blanco. Si quiere ignorar el espacio en blanco, use la opción -b. Use la opción -B para ignorar las líneas en blanco. Finalmente, use -i para ignorar el caso.

El comando diff también puede aplicarse a los directorios. El comando

diff dir1 dir2

muestra los archivos presentes en cualquiera de los dos directorios; ya sea que los archivos estén presentes en uno de los directorios o en ambos. Si se encuentra un subdirectorio con el mismo nombre, no se detiene a ver si algún archivo individual difiere. Un ejemplo:

# diff DBA102 PROPRD Common subdirectories: DBA102/adump and PROPRD/adumpOnly in DBA102: afiedt.bufOnly in PROPRD: archiveOnly in PROPRD: BACKUPOnly in PROPRD: BACKUP1Only in PROPRD: BACKUP2Only in PROPRD: BACKUP3Only in PROPRD: BACKUP4Only in PROPRD: BACKUP5Only in PROPRD: BACKUP6Only in PROPRD: BACKUP7Only in PROPRD: BACKUP8Only in PROPRD: BACKUP9Common subdirectories: DBA102/bdump and PROPRD/bdumpCommon subdirectories: DBA102/cdump and PROPRD/cdumpOnly in PROPRD: CreateDBCatalog.logOnly in PROPRD: CreateDBCatalog.sqlOnly in PROPRD: CreateDBFiles.logOnly in PROPRD: CreateDBFiles.sqlOnly in PROPRD: CreateDB.logOnly in PROPRD: CreateDB.sqlOnly in DBA102: dpdumpOnly in PROPRD: emRepository.sqlOnly in PROPRD: init.oraOnly in PROPRD: JServer.sqlOnly in PROPRD: logOnly in DBA102: oradataOnly in DBA102: pfileOnly in PROPRD: postDBCreation.sqlOnly in PROPRD: RMANTEST.shOnly in PROPRD: RMANTEST.sqlCommon subdirectories: DBA102/scripts and PROPRD/scriptsOnly in PROPRD: sqlPlusHelp.logCommon subdirectories: DBA102/udump and PROPRD/udump

Vea que los subdirectorios comunes simplemente se muestran como tal pero no se realiza ninguna comparación. Si desea hacer más desgloses y comparar los archivos de esos subdirectorios, debería utilizar el siguiente comando:

diff -r dir1 dir2

Este comando ingresa repetitivamente en cada subdirectorio para comparar los archivos e informa la diferencia entre los archivos con el mismo nombre.


Un uso común de diff es diferenciar entre distintos archivos init.ora. Como ejemplo modelo, siempre copio el archivo con un nuevo nombre—por ej., initDBA102.ora con initDBA102.080306.ora (para indicar 3 de agosto de 2006) —antes de realizar un cambio. Un simple diff entre todas las versiones del archivo muestra rápidamente qué cambió y cuándo.

Este es un comando bastante poderoso para administrar su página de inicio Oracle. Como ejemplo modelo, nunca actualizo una Página de Inicio de Oracle cuando aplico parches. Por ejemplo, supongamos que las versiones Oracle actuales sean 10.2.0.1. ORACLE_HOME podría ser /u01/app/oracle/product/10.2/db1. Cuando llega el momento de realizar un parche hacia 10.2.0.2, no realizo el parche de esta Página de Inicio Oracle. En cambio, inicio una instalación nueva en /u01/app/oracle/product/10.2/db2 y luego realizo un parche de esa página de inicio. Una vez listo, uso lo siguiente:

# sqlplus / as sysdbaSQL> shutdown immediateSQL> exit# export ORACLE_HOME=/u01/app/oracle/product/10.2/db2# export PATH=$ORACLE_HOME/bin:$PATH# sqlplus / as sysdbaSQL> @$ORACLE_HOME/rdbms/admin/catalog...

y así sucesivamente.

El propósito de este enfoque es que la Página de Inicio Oracle original no se interrumpa y que pueda fácilmente volver atrás en caso de haber problemas. Esto también implica que la base de datos deja de funcionar y vuelve a hacerlo, con bastante rapidez. Si hubiese instalado un parche directamente en la Página de Inicio Oracle, hubiese tenido que interrumpir la base de datos durante mucho tiempo—mientras dure la aplicación del parche. Asimismo, si la aplicación del parche hubiese fallado por algún motivo, no hubiese obtenido una Página de Inicio Oracle “limpia”.

Ahora que tengo varias Páginas de Inicio Oracle, ¿cómo puedo ver qué cambió? Es realmente simple; puedo utilizar:

diff -r /u01/app/oracle/product/10.2/db1 /u01/app/oracle/product/10.2/db2 | grep -v Common

Esto me muestra las diferencias entre ambas Páginas de Inicio Oracle y las diferencias entre los archivos con el mismo nombre. Algunos archivos importantes como tnsnames.ora, listener.ora y sqlnet.ora no deberían mostrar grandes diferencias, pero si lo hacen, debo entender por qué.

cmp. El comando cmp es similar a diff:

# cmp file1 file2 file1 file2 differ: byte 10, line 1

El output vuelve a aparecer como la primera señal de diferencia. Usted puede utilizar esto para identificar en qué pueden diferir los archivos. diff, cmp tiene muchas opciones, la más importante es la opción -s, lo cual sencillamente genera un código

• 0, si los archivos son idénticos • 1, si difieren • Algún otro número que no sea cero, si la comparación no pudo realizarse

Un ejemplo:

# cmp -s file3 file4

# echo $?0

La variable especial $? indica el código del último comando ejecutado. En este caso, 0, lo cual implica que los archivos 1 y 2 son idénticos.

# cmp -s file1 file2# echo $?1

implica que los archivos 1 y 2 no son iguales.

Esta propiedad de cmp puede resultar muy útil en shell scripting donde simplemente quiera verificar si dos archivos difieren de alguna manera, pero no necesariamente verificar cuál es la diferencia. Otro uso importante de este comando es comparar los archivos binarios, donde diff puede no ser confiable.


Recuerde de un consejo anterior, cuando vuelve a conectar los ejecutables Oracle, la versión más antigua se guarda antes de sobrescribirla. Por lo tanto, cuando se vuelve a conectar, el ejecutable sqlplus es renombrado como “sqlplusO”, y el recientemente compilado sqlplus es colocado en $ORACLE_HOME/bin. ¿Entonces cómo se asegura de que el sqlplus que se creó recientemente es diferente? Simplemente utilice:

# cmp sqlplus sqlplusOsqlplus sqlplusO differ: byte 657, line 7

Si verifica el tamaño:

# ls -l sqlplus*-rwxr-x--x 1 oracle dba 8851 Aug 4 05:15 sqlplus-rwxr-x--x 1 oracle dba 8851 Nov 2 2005 sqlplusO

A pesar de que el tamaño es el mismo en ambos casos, cmp demostró que los dos programas son diferentes.

comm. El comando comm es similar a los otros pero el output se genera en tres columnas, separadas por etiquetas. Ejemplo:

# comm file1 file2 In file1 and file2In file1 onlyIn file1 and file2 In file2 only

Este comando es útil para ver los contenidos de un archivo y no del otro, no solo una diferencia—una clase de herramienta MINUS en el lenguaje SQL. La opción -1 suprime los contenidos del primer archivo:

Resumen de Comandos de este Documento

CommandoUso

chmod

Para cambiar permisos de un archivo, usando el parámetro de referencia - -

chown

Para cambiar el propietario de un archivo, usando el parámetro de referencia - -

chgrp

Para cambiar el grupo de un archivo, usando el parámetro de referencia - -

stat

Para conocer los atributos extendidos de un archivo, como fecha de último acceso

file

Para conocer el tipo de archivo, como ASCII, datos, etc.

diff

Para ver la diferencia entre dos archivos

cmp

Para comparar dos archivos

comm

Para ver qué tienen en común dos archivos, con el output en tres columnas

md5sum

# comm -1 file1 file2In file1 and file2In file2 only

md5sum. Este comando genera un valor arbitrario MD5 de 32 bits de los archivos:

# md5sum file1ef929460b3731851259137194fe5ac47 file1

Dos archivos con la misma suma de control (checksum) pueden considerarse idénticos. No obstante, la utilidad de este comando va más allá de simplemente comparar los archivos. También puede ofrecer un mecanismo para garantizar la integridad de los archivos.

Supongamos que tiene dos archivos importantes—archivo1 y 2—que necesita proteger. Puede utilizar el control de opción --check para confirmar que los archivos no han cambiado. Primero, cree un archivo de suma de control para ambos archivos importantes y manténgalos protegidos:

# md5sum file1 file2 > f1f2

Luego, cuando quiere verificar que los archivos siguen intactos:

# md5sum --check f1f2 file1: OKfile2: OK

Esto muestra claramente que los archivos no han sido modificados. Ahora cambia un archivo y verifique el MD5:

# cp file2 file1# md5sum --check f1f2file1: FAILEDfile2: OKmd5sum: WARNING: 1 of 2 computed checksums did NOT match

El output claramente muestra que el archivo 1 ha sido modificado.


md5sum es un comando extremadamente poderoso para implementaciones de seguridad. Algunos archivos de configuración que administra, como listener.ora, tnsnames.ora e init.ora, son demasiado críticos para una infraestructura Oracle exitosa, y cualquier modificación puede dar como resultado momentos de inactividad. Esto en general forma parte de su proceso de control de cambios. En lugar de confiar en la palabra de alguien respecto de que estos archivos no han cambiado, asegúrese utilizando la suma de control MD5. Cree un archivo de suma de control y, cuando realice un cambio planificado, vuelva a crear este archivo. Como parte del cumplimiento, verifique este archivo utilizando el comando md5sum. Si alguien actualizara involuntariamente alguno de estos archivos clave, inmediatamente se daría cuenta del cambio.

En la misma línea, también puede crear sumas de control MD5 para todos los ejecutables de $ORACLE_HOME/bin y compararlas de vez en cuando para realizar modificaciones no autorizadas.

Conclusión Hasta ahora, ha aprendido solo algunos de los comandos Linux que encontrará útiles para realizar una tarea con eficiencia. En el próximo documento, describiré algunos comandos más sofisticados pero útiles, como strace, whereis, renice, skill, y mucho más.

Guía para Maestría Avanzada de Comandos Linux Parte 2

por Arup Nanda

Publicado en febrero de 2008

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 unaliasSupongamos 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'

http://www.oracle.com/technology/global/lad-es/pub/articles/advanced-linux-commands/part1.html

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

lsEl 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.

$ lsadmin has mesg precompapex hs mgw racgassistants install network rdbms... output snipped ...

Para mostrarlos en una lista, use la opción -1 (el número 1, no la letra "l").

$ ls -1adminapexassistants... 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 272drwxr-xr-x 3 oracle oinstall 4096 Sep 3 03:27 admindrwxr-x--- 7 oracle oinstall 4096 Sep 3 02:32 apexdrwxr-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 -Fdir1/ 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 dir1total 4drwxr-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 dir1drwxr-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.shdrwxr-xr-x 2 oracle oinstall 8192 Oct 11 18:14 bindrwxr-x--- 3 oracle oinstall 8192 Sep 23 23:49 lib

xargsLa 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 textalert_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.logalert_DBA102.log.Zdba102_asmb_12307.trc.Zdba102_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.logls -ltr alert_DBA102.log.Zls -ltr dba102_asmb_12307.trc.Zls -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 vivi 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 -lwc -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.logls -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.trcls -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.

renameComo sabe, el comando mv renombra los archivos. Por ejemplo,

$ mv oldname newname

Renombra el archivo oldname como newname. Sim embargo ¿Que ocurre si aún no sabes los nombres de los archivos? El comando rename se vuelve realmente complicado aquí.

rename .log .log.‘date +%F-%H:%M:%S‘ *

reemplaza todos los archivos con la extensión .log por .log.<dateformat>. Entonces sqlnet.log se convierte en sqlnet.log.2006-09-12-23:26:28.

findEnte 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 ProductionWith the Partitioning, Real Application Clusters, OLAP and Oracle Data Mining optionsJServer Release 9.2.0.5.0 - Production SQL> exitDisconnected from Oracle9i Enterprise Edition Release 9.2.0.5.0 - 64bit ProductionWith the Partitioning, Real Application Clusters, OLAP and Oracle Data Mining optionsJServer 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ó.


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 {} \;

m4Este 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 tempThe 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 tempThe 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_commandwhich: 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 lsalias 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

topEl 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_cSwap: 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 procesoMientras 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.


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.programfrom v$session s, v$process pwhere spid = 16143and 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 sniceEn 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.

Guía para Maestría Avanzada en Comandos Linux, Parte 3: Administración de Recursos

por Arup Nanda

Publicado en enero de 2009

En esta entrega, aprenda los comandos avanzados de Linux para monitorear componentes físicos

Un sistema Linux está conformado por varios componentes físicos clave como CPU, memorias, tarjetas de red y dispositivos de almacenamiento. Para administrar de manera efectiva el entorno Linux, usted debería poder evaluar varias métricas de estos recursos—cuánto procesa cada componente, si existen cuellos de botella, entre otras cosas —con una precisión razonable.

En otras partes de esta serie usted aprendió algunos comandos para medir las métricas en un nivel macro. En esta entrega, no obstante, aprenderá los comandos avanzados de Linux para monitorear componentes físicos. En especial, aprenderá acerca de los comandos en las siguientes categorías:

Component Commands

Memory free, vmstat, mpstat, iostat, sar

CPU vmstat, mpstat, iostat, sar

I/O vmstat, mpstat, iostat, sar

Processes ipcs, ipcrm

Como puede observar, algunos comandos aparecen en más de una categoría. Esto se debe a que los comandos pueden desempeñar muchas tareas. Algunos comandos se ajustan mejor a otros componentes –por ej., iostat para I/O—pero debería comprender las diferencias en sus trabajos y utilizar aquellos con los que se sienta más cómodo.

En la mayoría de los casos, un solo comando no es útil para comprender lo que realmente está sucediendo. Usted debería conocer múltiples comandos para obtener la información que desea.

"free"Una pregunta común es, “¿Cuánta memoria está siendo utilizada por mis aplicaciones y los distintos servidores, usuarios y procesos de sistemas?” O, “¿Cuánto espacio de memoria tengo libre en este momento?” Si la memoria utilizada por los procesos en ejecución es mayor la memoria RAM disponible, los procesos se trasladan a la memoria swap (memoria virtual). Por lo tanto, una pregunta complementaria sería, “¿Qué cantidad de memoria swap se está utilizando?”.

El comando “free” responde a todas estas preguntas. Es más, una opción muy útil, –m , muestra la memoria libre en megabytes:

# free -m total used free shared buffers cachedMem: 1772 1654 117 0 18 618-/+ buffers/cache: 1017 754Swap: 1983 1065 918

El output muestra que el sistema tiene 1.772 MB de RAM, de los cuales se utilizan 1.654 MB, dejando 117 MB de memoria libre. La segunda línea muestra los cambios de tamaño de caché y buffers en la memoria física. La tercera línea muestra la utilización de memoria swap.

Para expresar lo mismo en kilobytes y gigabytes, reemplace la opción -m con -k o -g respectivamente. Usted puede colocarse en el nivel de bytes también, utilizando la opción –b.

# free -b total used free shared buffers cachedMem: 1858129920 1724039168 134090752 0 18640896 643194880-/+ buffers/cache: 1062203392 795926528Swap: 2080366592 1116721152 963645440

La opción –t muestra el total al final del output (suma de memoria física más swap):

# free -m -t total used free shared buffers cachedMem: 1772 1644 127 0 16 613-/+ buffers/cache: 1014 757Swap: 1983 1065 918Total: 3756 2709 1046

A pesar de que “free” no muestra los porcentajes, podemos extraer y formatear partes específicas del output para mostrar la memoria utilizada como porcentaje del total solamente:

# free -m | grep Mem | awk '{print ($3 / $2)*100}' 98.7077

Esto viene bien para los shell scripts en donde las cantidades específicas son importantes. Por ejemplo, usted quizás quiera generar un alerta cuando el porcentaje de memoria libre descienda por debajo de cierto límite.

De modo similar, para encontrar el porcentaje de swap utilizado, usted puede emitir:

free -m | grep -i Swap | awk '{print ($3 / $2)*100}'

Puede utilizar free para observar la carga de memoria empleada por una aplicación. Por ejemplo, controle la memoria libre antes de iniciar una aplicación de backup y luego contrólela inmediatamente luego de iniciarla. La diferencia podría atribuirse al consumo por parte de la aplicación de backup.

Para Usuarios de Oracle

Entonces, ¿cómo puede utilizar este comando para administrar el servidor Linux que ejecuta su entorno de Oracle? Una de las causas más comunes de los problemas de desempeño es la falta de memoria, lo que provoca que el sistema “intercambie” áreas de memoria en el disco de manera temporal. Cierto grado de intercambio es probablemente inevitable pero experimentar una gran cantidad de intercambio puede indicar falta de memoria libre.

En cambio, usted puede utilizar free para obtener información de la memoria libre y ahora hacer el seguimiento con el comando sar (que se muestra luego) para controlar la tendencia histórica del consumo de memoria y swap. Si el uso de swap es temporario, es probable que se trate de un pico (spike) por única vez; pero si se declara durante un período de tiempo, debería hacerlo notar. Existen algunas sospechas posibles y obvias de sobrecarga crónica de memoria:

SGA más amplia que la memoria disponible Amplia asignación en PGA Algunos procesos con bugs que producen la fuga de de memoria

Para el primer caso, usted debería asegurarse de que SGA sea menor a la memoria disponible. La regla general es utilizar alrededor del 40 por ciento de la memoria física para SGA, no obstante, debería definir ese parámetro sobre la base de su situación específica. En el segundo caso, usted debería intentar reducir la amplia asignación de buffers en consultas. En el tercer caso debería utilizar el comando “ps” (descripto en entregas anteriores de esta serie) para identificar el proceso específico que podría producir la fuga de memoria.

"ipcs"Cuando se ejecuta un proceso, se adopta desde la “memoria compartida”. Puede haber uno o muchos segmentos de memoria compartida por proceso. Los procesos intercambian mensajes entre ellos (“comunicaciones entre procesos”, o IPC) y utilizan semáforos. Para desplegar información sobre segmentos de memoria compartida, colas de mensajes IPC y semáforos, usted puede utilizar un solo comando: ipcs.

La opción –m es muy conocida; despliega los segmentos de memoria compartida.

# ipcs -m ------ Shared Memory Segments --------key shmid owner perms bytes nattch status 0xc4145514 2031618 oracle 660 4096 0 0x00000000 3670019 oracle 660 8388608 108 0x00000000 327684 oracle 600 196608 2 dest 0x00000000 360453 oracle 600 196608 2 dest 0x00000000 393222 oracle 600 196608 2 dest 0x00000000 425991 oracle 600 196608 2 dest 0x00000000 3702792 oracle 660 926941184 108 0x00000000 491529 oracle 600 196608 2 dest 0x49d1a288 3735562 oracle 660 140509184 108 0x00000000 557067 oracle 600 196608 2 dest 0x00000000 1081356 oracle 600 196608 2 dest 0x00000000 983053 oracle 600 196608 2 dest 0x00000000 1835023 oracle 600 196608 2 dest

Este output, tomado de un servidor que ejecuta software de Oracle, muestra los distintos segmentos de memoria compartida. Cada uno se identifica exclusivamente por un ID de memoria compartida, y se muestra en la columna “shmid”. (Más adelante verá cómo utilizar el valor de esta columna.) El “owner”, por supuesto, muestra el propietario del segmento, la columna “perms” muestra los permisos (igual que los permisos unix), y “bytes” muestra el tamaño de los bytes.

La opción -u muestra un breve resumen:

# ipcs -mu

------ Shared Memory Status --------segments allocated 25pages allocated 264305pages resident 101682pages swapped 100667Swap performance: 0 attempts 0 successes

La opción –l muestra los límites (en contraposición a los valores actuales):

# ipcs -ml ------ Shared Memory Limits --------max number of segments = 4096max seg size (kbytes) = 907290max total shared memory (kbytes) = 13115392min seg size (bytes) = 1

Si usted ve que los valores reales se acercan o se encuentran en el límite, debería extender ese límite.

Puede obtener un panorama detallado de un segmento de memoria compartida utilizando el valor shmid. La opción –i logra esto. Usted verá los detalles de shmid 3702792:

# ipcs -m -i 3702792 Shared memory Segment shmid=3702792uid=500 gid=502 cuid=500 cgid=502mode=0660 access_perms=0660bytes=926941184 lpid=12225 cpid=27169 nattch=113att_time=Fri Dec 19 23:34:10 2008 det_time=Fri Dec 19 23:34:10 2008 change_time=Sun Dec 7 05:03:10 2008

Más adelante verá un ejemplo de cómo interpretar el output de arriba.

La opción -s muestra los semáforos en el sistema:

# ipcs -s ------ Semaphore Arrays --------key semid owner perms nsems 0x313f2eb8 1146880 oracle 660 104 0x0b776504 2326529 oracle 660 154 … and so on …

Esto muestra algunos de datos valiosos. Se observa que el grupo de semáforos de ID 1146880 posee 104 semáforos, y el otro tiene 154. Si usted los suma, el valor total debe ser menor al límite máximo definido por el parámetro kernel (semmax). Mientras se instala el software de la Base de Datos de Oracle, el controlador de preinstalación debe controlar los parámetros para semmax. Luego, cuando el sistema alcanza el estado seguro, usted puede controlar la utilización real y luego ajustar el valor kernel de manera adecuada.


¿Cómo puede descubrir los segmentos de memoria compartida utilizados por la instancia de Base de Datos de Oracle? Para lograrlo, utilice el comando oradebug. Primero conéctese a la base de datos como sysdba:

# sqlplus / as sysdba

En el SQL, utilice el comando oradebug como se muestra abajo:

SQL> oradebug setmypidStatement processed.SQL> oradebug ipcInformation written to trace file.

Para descubrir el nombre del archivo de rastreo:

SQL> oradebug TRACEFILE_NAME/opt/oracle/diag/rdbms/odba112/ODBA112/trace/ODBA112_ora_22544.trc

Ahora, si abre un archivo de rastreo, usted verá los IDs de la memoria compartida. Aquí se muestra un extracto del archivo:

Area #0 `Fixed Size' containing Subareas 0-0 Total size 000000000014613c Minimum Subarea size 00000000 Area Subarea Shmid Stable Addr Actual Addr 0 0 17235970 0x00000020000000 0x00000020000000 Subarea size Segment size 0000000000147000 000000002c600000 Area #1 `Variable Size' containing Subareas 4-4 Total size 000000002bc00000 Minimum Subarea size 00400000 Area Subarea Shmid Stable Addr Actual Addr 1 4 17235970 0x00000020800000 0x00000020800000 Subarea size Segment size 000000002bc00000 000000002c600000 Area #2 `Redo Buffers' containing Subareas 1-1 Total size 0000000000522000 Minimum Subarea size 00000000 Area Subarea Shmid Stable Addr Actual Addr 2 1 17235970 0x00000020147000 0x00000020147000 Subarea size Segment size 0000000000522000 000000002c600000... and so on ...

El ID de memoria compartida se muestra en letra mayúsculas rojas. Usted puede utilizar este ID de memoria compartida para obtener los detalles de la memoria compartida:

# ipcs -m -i 17235970

Otra observación útil es el valor de lpid – el ID del proceso que por última vez alcanzó el segmento de memoria compartida. Para demostrar el valor en ese atributo, utilice SQL*Plus para conectarse a la instancia desde una sesión distinta.

# sqlplus / as sysdba

En esa sesión, descubra el PID del proceso del servidor:

SQL> select spid from v$process 2 where addr = (select paddr from v$session 3 where sid = 4 (select sid from v$mystat where rownum < 2) 5 ); SPID------------------------13224

Ahora vuelva a ejecutar el comando “ipcs” frente al mismo segmento de memoria compartida:

# ipcs -m -i 17235970

Shared memory Segment shmid=17235970uid=500 gid=502 cuid=500 cgid=502mode=0660 access_perms=0660bytes=140509184 lpid=13224 cpid=27169 nattch=113att_time=Fri Dec 19 23:38:09 2008 det_time=Fri Dec 19 23:38:09 2008 change_time=Sun Dec 7 05:03:10 2008

Preste atención al valor de “lpid”, que fue cambiado a 13224 desde el valor original 12225. El “lpid” muestra el PID del último proceso que alcanzó el segmento de memoria compartida, y observe cómo cambiaron los valores.

El comando por sí mismo, ofrece poco valor. El próximo comando – ipcrm – le permite actuar en base al output, como verá en la próxima sección.

ipcrmAhora que ha identificado la memoria compartida y demás métricas de IPC ¿qué hacer con ellas? Usted ya ha conocido su uso, por ejemplo, identificar le memoria compartida utilizada por Oracle, asegurar que el parámetro kernel para la memoria compartida haya sido establecido, etc. Otra aplicación común es eliminar la memoria compartida, la cola de mensajes IPC, o los grupos de semáforos.

Para eliminar el segmento de memoria compartida, observe su “shmid” del output del comando “ipcs”. Luego utilice la opción –m para eliminar el segmento. Para remover el segmento con ID 3735562, utilice

# ipcrm –m 3735562

Esto eliminará la memoria compartida. Usted también puede utilizarlo para eliminar colas de mensajes IPC y semáforos (utilizando los parámetros –s y –q).


Algunas veces cuando se cierra la instancia de base de datos, los segmentos de memoria compartida pueden no eliminarse por completo por el kernel de Linux. La memoria compartida que queda no es utilizada; no obstante, invade los recursos del sistema reduciendo la cantidad de memoria disponible para otros procesos. En ese caso, usted puede controlar cualquier segmento de memoria compartida persistente que posee el usuario “oracle” y luego eliminarlo, si corresponde, utilizando el comando ”ipcrm”.

vmstatCuando se invoca vmstat, denominado el “abuelo” de todas las visualizaciones relacionadas con procesos y memorias, continuamente ejecuta y entrega su información. Toma dos segmentos:

# vmstat <interval> <count>

<interval> es el intervalo en segundos entre dos ejecuciones. <count> es la cantidad de repeticiones que vmstat realiza. Vea un ejemplo de cuando usted desea que vmstat se ejecute cada cinco segundos y se detenga luego de la décima vez. Cada línea en el output se despliega después de cinco segundos y muestra las estadísticas en ese momento.

# vmstat 5 10

procs -----------memory---------- ---swap-- -----io---- --system-- ----cpu----

r b swpd free buff cache si so bi bo in cs us sy id wa 0 0 1087032 132500 15260 622488 89 19 9 3 0 0 4 10 82 5 0 0 1087032 132500 15284 622464 0 0 230 151 1095 858 1 0 98 1 0 0 1087032 132484 15300 622448 0 0 317 79 1088 905 1 0 98 0… shows up to 10 times.

El output muestra mucha información sobre los recursos del sistema. Veámoslos en detalle:

procs Muestra la cantidad de procesos

r Proceso en espera para ser ejecutado. Cuanto mayor es la carga del sistema, mayor la cantidad de procesos que esperan que los ciclos de CPU se ejecuten.

b Procesos en espera ininterrumpible, también conocidos como procesos “bloqueados”. Estos procesos generalmente esperan una I/O, pero también podrían referirse a otras cosas.

Algunas veces hay otra columna que se denomina “w”, la cual muestra la cantidad de procesos que pueden ser ejecutados pero que se han intercambiado al área de swap.

La cantidad que muestra “b” debería ser cercana a 0. Si la cantidad que se muestra en “w” es elevada, usted puede necesitar más memoria.

El siguiente cuadro muestra las métricas de memoria::

swpd Cantidad de memoria virtual o memoria swap (en KB)

free Cantidad de memoria física libre (en KB)

buff Cantidad de memoria utilizada como buffer (en KB)

cache Kilobytes de memoria física utilizados como caché

La memoria de buffer se utiliza para almacenar metadatos de archivos como i-nodes y datos de dispositivos de bloques en bruto. La memoria de caché se utiliza para datos de archivos.

El siguiente cuadro muestra la actividad de swap:

si Índice en el cual la memoria realiza el intercambio del disco a la RAM física (en KB/seg.)

so Índice en el cual la memoria realiza el intercambio al disco desde la memoria RAM física (en KB/seg.)

El siguiente cuadro muestra la actividad de I/O:

bi Índice en el cual el sistema envía datos a los dispositivos de bloque (en bloques/seg.)

bo Índice en el cual el sistema lee los datos desde los dispositivos de bloque (en bloques/seg.)

El siguiente cuadro muestra las actividades relacionadas con el sistema:

in Cantidad de interrupciones del sistema por segundo

cs Índice de cambios de contexto en el espacio del proceso (en cantidad /seg.)

El último cuadro es probablemente el más utilizado –información sobre la carga de CPU:

us Muestra el porcentaje de CPU utilizado en los procesos del usuario. Los procesos de Oracle se presentan en esta categoría.

sy Porcentaje de CPU utilizado por los procesos del sistema, tales como los procesos de raíz

id Porcentaje de CPU libre

wa Porcentaje utilizado en “espera por I/O”

Veamos cómo interpretar estos valores. La primera línea del output es un promedio de todas las métricas desde el reinicio del sistema. Por lo tanto, ignore esa línea ya que no muestra el estado real. Las demás líneas muestran las métricas en tiempo real.

De modo ideal, la cantidad de procesos en espera o bloqueados (bajo el encabezado “procs”) debería ser 0 o cercana a 0. Si ésta es elevada, entonces el sistema no tiene demasiados recursos como CPU, memoria o I/O. Esta información resulta útil al momento de diagnosticar los problemas de desempeño.

Los datos bajo “swap” indican si se está produciendo un exceso de intercambio. Si ese es el caso, entonces quizás tenga memoria física inadecuada. Usted debería reducir la demanda de memoria o aumentar la memoria RAM física.

Los datos bajo “io” indican el flujo de datos desde y hasta el disco. Esto muestra la actividad del disco, sin indicar necesariamente la existencia de algún problema. Si usted observa un número elevado en “proc” y luego en la columna “b” (procesos que están siendo bloqueados) y I/O elevado, el problema podría deberse a una contención I/O severa.

La información más útil se presenta en el encabezado “cpu”. La columna “id” muestra la CPU inactiva. Si usted resta 100 a esa cantidad, obtiene el porcentaje de CPU ocupada. ¿Recuerda el comando “top” descripto en otra entrega de esta serie? Ese también muestra el porcentaje de CPU libre. La diferencia es: el comando “top” muestra el porcentaje libre para cada CPU mientras que el vmstat muestra la visión consolidada de todas las CPU.

El comando “vmstat” también muestra el desglose del uso de CPU: qué cantidad es utilizada por el sistema Linux, qué cantidad por un proceso de usuarios y por la espera para I/O. A partir de este desglose usted puede determinar qué contribuye al consumo de la CPU. Si la carga del sistema de CPU es alta, ¿podría haber algún proceso raíz como un backup en ejecución?

La carga del sistema debería ser consistente durante un período de tiempo. Si el sistema muestra una cantidad elevada, utilice el comando “top” para identificar el porcentaje de consumo de CPU.


Los procesos de Oracle (los procesos de antecedentes y del servidor) y los procesos de usuarios (sqlplus, apache, etc.) figuran bajo “us”. Si esta cantidad es elevada, utilice “top” para identificar los procesos. Si la columna “wa” muestra una cantidad elevada, esto indica que el sistema I/O no puede alcanzar la cantidad de lectura o escritura. Esto podría ocasionalmente disparar un resultado

de picos en actualizaciones a la base de datos, lo que podría causar un cambio de registro y un pico posterior en los procesos de archivo. Pero, si muestra consistentemente una cifra elevada, entonces podría estar en presencia de un cuello de botella de I/O.

Las obstrucciones de I/O en una base de datos de Oracle pueden causar serios problemas. Aparte de los problemas de desempeño, el lento flujo de I/O podría provoca enlentecer las escrituras de “controlfile”, lo que provocaría la espera de un proceso hasta adquirir “controlfile” en cola. Si la espera es de más de 900 segundos, y un proceso crítico está en espera, como LGWR, se elimina la instancia de base de datos.

Si el nivel de intercambio (swapping) es elevado, tal vez el tamaño de SGA sea muy alto para ajustarse a la memoria física. Usted debería reducir el tamaño de SGA o aumentar la memoria física.

mpstatOtro comando útil para obtener las estadísticas relacionadas con la CPU es “mpstat”. Aquí se muestra un ejemplo del output:

# mpstat -P ALL 5 2Linux 2.6.9-67.ELsmp (oraclerac1) 12/20/2008 10:42:38 PM CPU %user %nice %system %iowait %irq %soft %idle intr/s10:42:43 PM all 6.89 0.00 44.76 0.10 0.10 0.10 48.05 1121.6010:42:43 PM 0 9.20 0.00 49.00 0.00 0.00 0.20 41.60 413.0010:42:43 PM 1 4.60 0.00 40.60 0.00 0.20 0.20 54.60 708.40 10:42:43 PM CPU %user %nice %system %iowait %irq %soft %idle intr/s10:42:48 PM all 7.60 0.00 45.30 0.30 0.00 0.10 46.70 1195.0110:42:48 PM 0 4.19 0.00 2.20 0.40 0.00 0.00 93.21 1034.5310:42:48 PM 1 10.78 0.00 88.22 0.40 0.00 0.00 0.20 160.48 Average: CPU %user %nice %system %iowait %irq %soft %idle intr/sAverage: all 7.25 0.00 45.03 0.20 0.05 0.10 47.38 1158.34Average: 0 6.69 0.00 25.57 0.20 0.00 0.10 67.43 724.08Average: 1 7.69 0.00 64.44 0.20 0.10 0.10 27.37 434.17

Muestra las distintas estadísticas para las CPU del sistema. Las opciones –P ALL ordena al comando desplegar las estadísticas de todas las CPU, no solamente de una específica. Los parámetros 5 2 ordenan al comando ejecutarse cada 5 segundos y durante 2 veces. El output de arriba muestra las métricas para todas las primeras CPU (agrupadas) y para cada CPU individualmente. Finalmente, el porcentaje para todas las CPU se muestra al final.

Veamos el significado de los valores de las columnas:

%user Indica el porcentaje de procesamiento para la CPU consume por proceso de usuario. Los procesos de usuarios son procesos que no son kernel utilizados para aplicaciones como las de la base de datos de Oracle. En este

output de ejemplo, el porcentaje de CPU de usuario es muy pequeño.

%nice Indica el porcentaje de CPU cuando un proceso ha bajado su categoría por el comando nice. El comando nice ha sido descripto en una entrega anterior. En resumen, el comando nice cambia la prioridad de un proceso.

%system Indica el porcentaje de CPU utilizado por los procesos kernel

%iowait Muestra el porcentaje de tiempo de CPU utilizado por la espera de I/O

%irq Indica el porcentaje de CPU utilizado para manejar las interrupciones del sistema

%soft Indica el porcentaje utilizado para las interrupciones de software

%idle Muestra el tiempo de inactividad de la CPU

%intr/s Muestra la cantidad total de interrupciones que la CPU recibe por segundo

Usted podría preguntarse cuál es el propósito del comando mpstat cuando usted ya posee vmstat, descripto anteriormente. Existe una gran diferencia: mpstat puede mostrar las estadísticas por procesador, mientras que vmstat ofrece una visión consolidada de todos los procesadores. Por lo tanto, es posible que una aplicación escasamente escrita que no utilice una arquitectura de múltiples threads se ejecute sobre un motor de múltiples procesadores pero que no utilice todos los procesadores. Como resultado, se produce la sobrecarga de una CPU mientras que las demás permanecen libres. Usted puede diagnosticar fácilmente estas clases de problemas por medio de mpstat.


De modo similar a vmstat, el comando mpstat también produce estadísticas relacionadas con la CPU de manera que todos los debates relacionados con los problemas de CPU también se aplican a mpstat. Cuando usted observa un bajo nivel de %idle, sabe que está en presencia de una insuficiencia de CPU. Cuando observa una cantidad de %iowait mayor, usted sabe que existe algún

problema con el subsistema I/O en torno a la carga actual. Esta información resulta útil para resolver rápidamente los problemas de desempeño de la base de datos de Oracle.

iostatUna parte clave de la evaluación de desempeño es el desempeño del disco. El comando iostat brinda las métricas de desempeño de las interfaces de almacenamiento.

# iostatLinux 2.6.9-55.0.9.ELlargesmp (prolin3) 12/27/2008 avg-cpu: %user %nice %sys %iowait %idle 15.71 0.00 1.07 3.30 79.91 Device: tps Blk_read/s Blk_wrtn/s Blk_read Blk_wrtncciss/c0d0 4.85 34.82 130.69 307949274 1155708619cciss/c0d0p1 0.08 0.21 0.00 1897036 3659cciss/c0d0p2 18.11 34.61 130.69 306051650 1155700792cciss/c0d1 0.96 13.32 19.75 117780303 174676304cciss/c0d1p1 2.67 13.32 19.75 117780007 174676288sda 0.00 0.00 0.00 184 0sdb 1.03 5.94 18.84 52490104 166623534sdc 0.00 0.00 0.00 184 0sdd 1.74 38.19 11.49 337697496 101649200sde 0.00 0.00 0.00 184 0sdf 1.51 34.90 6.80 308638992 60159368sdg 0.00 0.00 0.00 184 0... and so on ...

La primera parte del output muestra las métricas como el espacio de CPU libre y las esperas I/O como ha podido ver en el comando mpstat.

La próxima parte del output muestra métricas muy importantes para cada uno de los dispositivos de disco en el sistema. Veamos lo que significan estas columnas:

Device Nombre del dispositivo

tps Cantidad de transferencias por segundo, es decir, cantidad de operaciones I/O por segundo. Nota: esta es solamente la cantidad de operaciones I/O; cada operación podría ser extensa o pequeña.

Blk_read/s

Cantidad de bloques leídos desde este dispositivo por segundo. Generalmente los bloques tienen un tamaño de 512 bytes. Este es el mejor valor de utilización de disco.

Blk_wrtn/s

Cantidad de bloques escritos en este dispositivo por segundo

Blk_read

Cantidad de bloques leídos desde este dispositivo al momento. Preste atención; no se refiere a lo que está sucediendo en ese momento. Estos bloques ya fueron leídos desde el dispositivo. Es posible que no se esté leyendo nada en ese momento. Observe esto por un rato para ver si se producen cambios.

Blk_wrt Cantidad de bloques escritos en el dispositivo

n

En un sistema con muchos dispositivos, el output podría aparecer a través de varias pantallas—haciendo que las cosas sean un poco difícil de examinar, especialmente si busca un dispositivo específico. Usted puede obtener las métricas para un dispositivo específico solamente utilizando ese dispositivo como parámetro.

# iostat sdaj Linux 2.6.9-55.0.9.ELlargesmp (prolin3) 12/27/2008 avg-cpu: %user %nice %sys %iowait %idle 15.71 0.00 1.07 3.30 79.91 Device: tps Blk_read/s Blk_wrtn/s Blk_read Blk_wrtnsdaj 1.58 31.93 10.65 282355456 94172401

Las métricas de CPU mostradas al comienzo pueden no ser demasiado útiles. Para eliminar las estadísticas relacionadas con la CPU en el comienzo del output, utilice la opción -d. Usted puede establecer parámetros adicionales al final para que iostat despliegue las estadísticas de dispositivo en intervalos regulares. Para obtener las estadísticas para este dispositivo cada 5 segundos durante 10 veces, emita lo siguiente:

# iostat -d sdaj 5 10

You can display the stats in kilobytes instead of just bytes using the -k option:

# iostat -k -d sdaj Linux 2.6.9-55.0.9.ELlargesmp (prolin3) 12/27/2008 Device: tps kB_read/s kB_wrtn/s kB_read kB_wrtnsdaj 1.58 15.96 5.32 141176880 47085232

A pesar de que el output de arriba puede ser útil, aún queda demasiada información que no está lista para ser desplegada. Por ejemplo, una de las causas de los problemas de disco es el tiempo de servicio de disco, es decir, la rapidez con la que el disco obtiene los datos para el proceso que los pide. Para alcanzar ese nivel de métricas, debemos obtener las estadísticas “extendidas” en el disco, utilizando la opción -x.

# iostat -x sdajLinux 2.6.9-55.0.9.ELlargesmp (prolin3) 12/27/2008 avg-cpu: %user %nice %sys %iowait %idle 15.71 0.00 1.07 3.30 79.91 Device: rrqm/s wrqm/s r/s w/s rsec/s wsec/s rkB/s wkB/s avgrq-sz avgqu-sz await svctm %utilsdaj 0.00 0.00 1.07 0.51 31.93 10.65 15.96 5.32 27.01 0.01 6.26 6.00 0.95

Veamos el significado de las columnas:

Device Nombre del dispositivo

rrqm/s Cantidad de solicitudes de lectura fusionas por segundo. Las solicitudes de disco que se colocan en cola. Cuando es posible, kernel intenta fusionar varias solicitudes en una. Esta métrica mide las transferencias de

fusión de las solicitudes de lectura.

wrqm/s Similar a la de lectura, esta es la cantidad de solicitudes de escritura fusionadas.

r/s Cantidad de solicitudes de lectura por segundo emitidas en este dispositivo

w/s Del mismo modo, se refiere a la cantidad de solicitudes de escritura por segundo

rsec/s Cantidad de sectores leídos desde este dispositivo por segundo

wsec/s Cantidad de sectores escritos en el dispositivo por segundo

rkB/s Datos leídos por segundo desde este dispositivo, en kilobytes por segundo

wkB/s Datos escritos en este dispositivo, en kb/s

avgrq-sz Tamaño promedio de solicitudes de lectura, en sectores

avgqu-sz Longitud promedio de la cola de solicitudes para este dispositivo

await Promedio de tiempo transcurrido (en milisegundos) para el dispositivo de solicitudes I/O. Esto es la suma del tiempo de servicio + el tiempo de espera en cola.

svctm Promedio del tiempo de servicio (en milisegundos) del dispositivo

%util Utilización de ancho de banda del dispositivo. Si es cercano al 100%, el dispositivo está saturado.

Ahora bien, tanta información puede presentar un desafío sobre cómo utilizarla de manera efectiva. La próxima sección muestra cómo utilizar el output.

Cómo Utilizarlo

Puede utilizar una combinación de comandos para obtener información del output. Recuerde, los discos podrían demorar en obtener la solicitud de los procesos. La cantidad de tiempo que le lleva al disco obtener los datos desde el disco y hasta la cola se denomina tiempo de servicio. Si desea ver los discos con los tiempos de servicio más elevados, usted debe emitir:

# iostat -x | sort -nrk13sdat 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 18.80 0.00 64.06 64.05 0.00sdv 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 17.16 0.00 18.03 17.64 0.00sdak 0.00 0.00 0.00 0.14 0.00 1.11 0.00 0.55 8.02 0.00 17.00 17.00 0.24sdm 0.00 0.00 0.00 0.19 0.01 1.52 0.01 0.76 8.06

0.00 16.78 16.78 0.32... and so on ...

Esto muestra que el sdat de disco tiene el tiempo de servicio más elevado (64.05 ms). ¿Por qué es tan alto? Puede haber varias posibilidades pero posiblemente éstas sean las tres más importantes:

1. El disco contiene muchas solicitudes, por lo tanto el tiempo de servicio promedio es alto 2. El disco está utilizando el máximo de ancho de banda. 3. El disco es inherentemente lento.

Al observar el output vemos que reads/sec y writes/sec es de 0.00 (no sucede prácticamente nada), por lo tanto podemos excluir la #1. La utilización también es de 0.00% (la última columna), por lo tanto podemos excluir la #2. Así queda la #3. No obstante, antes de llegar a la conclusión de que el disco es inherentemente lento, necesitamos observar aquel disco un poco más de cerca. Podemos examinar ese disco solo cada 5 segundos, unas 10 veces.

# iostat -x sdat 5 10

Si el output muestra el mismo porcentaje de tiempo de servicio, los mismos índices de lectura, podemos concluir que el #3 es el factor más probable. Si ellos cambian, entonces podemos obtener más claves para comprender por qué el tiempo de servicio es alto para este dispositivo.

De manera similar, podemos buscar en la columna de índice de lectura para desplegar el disco bajo índices constantes de lectura.

# iostat -x | sort -nrk6 sdj 0.00 0.00 1.86 0.61 56.78 12.80 28.39 6.40 28.22 0.03 10.69 9.99 2.46sdah 0.00 0.00 1.66 0.52 50.54 10.94 25.27 5.47 28.17 0.02 10.69 10.00 2.18sdd 0.00 0.00 1.26 0.48 38.18 11.49 19.09 5.75 28.48 0.01 3.57 3.52 0.61... and so on ...

La información lo ayuda a localizar un disco que está “activo”—es decir, sujeto a muchas lecturas o escrituras. Si el disco se encuentra verdaderamente activo, usted debería identificar la razón de ello; tal vez un filesystem definido en el disco está sujeto a demasiadas lecturas. Si ese es el caso, usted debería considerar el hecho de descartar filesystem de los discos para distribuir la carga, minimizando así la posibilidad de que un disco específico esté activo.

sarDe los debates anteriores, surge un thread común: Obtener métricas en tiempo real no es lo más importante; la tendencia histórica también es importante.

Además, tenga en cuenta esta situación: ¿cuántas veces alguien plantea un problema de desempeño y cuando usted comienza a investigar, todo vuelve a la normalidad? Los problemas de desempeño que han ocurrido en el pasado son difíciles de diagnosticar si carece de datos específicos. Finalmente, usted decidirá examinar el desempeño de los datos en los últimos días para obtener algunos parámetros o para realizar algunos ajustes.

El comando sar cumple con ese objetivo. sar significa System Activity Recorder, y registra las métricas de los componentes clave del sistema Linux—CPU, Memoria, Discos, Redes, etc.—en un lugar especial: directory /var/log/sa. Los datos se graban cada día en un archivo denominado sa<nn> en donde <nn> es el día de dos dígitos del mes. Por ejemplo, el archivo sa27 contiene los datos para el día 27 de ese mes. Estos datos pueden ser consultados por el comando sar.

La manera más sencilla de utilizar sar es sin ningún argumento ni opción. Por ejemplo:

# sarLinux 2.6.9-55.0.9.ELlargesmp (prolin3) 12/27/2008 12:00:01 AM CPU %user %nice %system %iowait %idle12:10:01 AM all 14.99 0.00 1.27 2.85 80.8912:20:01 AM all 14.97 0.00 1.20 2.70 81.1312:30:01 AM all 15.80 0.00 1.39 3.00 79.8112:40:01 AM all 10.26 0.00 1.25 3.55 84.93... and so on ...

El output muestra las métricas relacionadas con la CPU recogidas en intervalos de 10 minutos. Las columnas significan:

CPU Identificador de CPU; “all” significa todas las CPU

%user Porcentaje de CPU utilizado para los procesos de usuarios. Los procesos de Oracle se presentan en esta categoría.

%nice El % de utilización de CPU mientras se ejecuta una prioridad nice

%system El % de CPU que ejecuta los procesos del sistema

%iowait El % de CPU en espera para I/O

%idle El % de CPU inactiva en espera de trabajos

En el output anterior, podemos ver que el sistema se encuentra bien balanceado; en realidad, por debajo del nivel infrautilizado (como se muestra en el alto grado de inactividad). Profundizando más el output podemos ver lo siguiente:

... continued from above ...03:00:01 AM CPU %user %nice %system %iowait %idle03:10:01 AM all 44.99 0.00 1.27 2.85 40.8903:20:01 AM all 44.97 0.00 1.20 2.70 41.1303:30:01 AM all 45.80 0.00 1.39 3.00 39.8103:40:01 AM all 40.26 0.00 1.25 3.55 44.93... and so on ...

Esto nos muestra otra historia: el sistema fue cargado por algunos procesos de usuarios entre las 3:00 y las 3:40. Tal vez se estaba ejecutando una consulta extensa; o tal vez se estaba ejecutando un trabajo RMAN, consumiendo así toda esa CPU. Aquí es en donde el comando sar es útil –despliega los datos registrados que muestran información de un momento específico, no del momento actual. Esto es exactamente lo que usted necesita para cumplir con los tres objetivos detallados al comienzo de esta sección: obtener datos históricos, encontrar patrones de uso y comprender las tendencias.

Si usted desea ver datos sar de un día específico, simplemente abra sar con ese nombre de archivo, utilizando la opción -f como se muestra abajo (para abrir los datos del día 26)

# sar -f /var/log/sa/sa26

También se pueden desplegar datos en tiempo real, similar a vmstat o mpstat. Para obtener los datos cada 5 segundos, durante 10 veces, utilice:

# sar 5 10

Linux 2.6.9-55.0.9.ELlargesmp (prolin3) 12/27/2008 01:39:16 PM CPU %user %nice %system %iowait %idle01:39:21 PM all 20.32 0.00 0.18 1.00 78.5001:39:26 PM all 23.28 0.00 0.20 0.45 76.0801:39:31 PM all 29.45 0.00 0.27 1.45 68.8301:39:36 PM all 16.32 0.00 0.20 1.55 81.93… and so on 10 times …

¿Notó el valor “all” debajo el título CPU? Esto significa que las estadísticas fueron cargadas para todas las CPU. Para un sistema de procesador único, esto está bien; pero en sistemas con múltiples procesadores usted desea obtener las estadísticas tanto para cada CPU individual, como para el conjunto. La opción -P ALL cumple con esto.

#sar -P ALL 2 2Linux 2.6.9-55.0.9.ELlargesmp (prolin3) 12/27/2008 01:45:12 PM CPU %user %nice %system %iowait %idle01:45:14 PM all 22.31 0.00 10.19 0.69 66.8101:45:14 PM 0 8.00 0.00 24.00 0.00 68.0001:45:14 PM 1 99.00 0.00 1.00 0.00 0.0001:45:14 PM 2 6.03 0.00 18.59 0.50 74.8701:45:14 PM 3 3.50 0.00 8.50 0.00 88.0001:45:14 PM 4 4.50 0.00 14.00 0.00 81.5001:45:14 PM 5 54.50 0.00 6.00 0.00 39.5001:45:14 PM 6 2.96 0.00 7.39 2.96 86.7001:45:14 PM 7 0.50 0.00 2.00 2.00 95.50 01:45:14 PM CPU %user %nice %system %iowait %idle01:45:16 PM all 18.98 0.00 7.05 0.19 73.7801:45:16 PM 0 1.00 0.00 31.00 0.00 68.0001:45:16 PM 1 37.00 0.00 5.50 0.00 57.5001:45:16 PM 2 13.50 0.00 19.00 0.00 67.5001:45:16 PM 3 0.00 0.00 0.00 0.00 100.00

01:45:16 PM 4 0.00 0.00 0.50 0.00 99.5001:45:16 PM 5 99.00 0.00 1.00 0.00 0.0001:45:16 PM 6 0.50 0.00 0.00 0.00 99.5001:45:16 PM 7 0.00 0.00 0.00 1.49 98.51 Average: CPU %user %nice %system %iowait %idleAverage: all 20.64 0.00 8.62 0.44 70.30Average: 0 4.50 0.00 27.50 0.00 68.00Average: 1 68.00 0.00 3.25 0.00 28.75Average: 2 9.77 0.00 18.80 0.25 71.18Average: 3 1.75 0.00 4.25 0.00 94.00Average: 4 2.25 0.00 7.25 0.00 90.50Average: 5 76.81 0.00 3.49 0.00 19.70Average: 6 1.74 0.00 3.73 1.49 93.03Average: 7 0.25 0.00 1.00 1.75 97.01

Esto muestra el identificador de CPU (comenzando con 0) y las estadísticas para cada uno. Al final del output usted verá el promedio de ejecuciones de cada CPU.

El comando sar no solo es para estadísticas relacionadas con la CPU. También es útil obtener las estadísticas relacionadas con la memoria. La opción -r muestra la utilización de memoria extensiva.

# sar -rLinux 2.6.9-55.0.9.ELlargesmp (prolin3) 12/27/2008 12:00:01 AM kbmemfree kbmemused %memused kbbuffers kbcached kbswpfree kbswpused %swpused kbswpcad12:10:01 AM 712264 32178920 97.83 2923884 25430452 16681300

95908 0.57 38012:20:01 AM 659088 32232096 98.00 2923884 25430968 16681300 95908 0.57 38012:30:01 AM 651416 32239768 98.02 2923920 25431448 16681300 95908 0.57 38012:40:01 AM 651840 32239344 98.02 2923920 25430416 16681300 95908 0.57 38012:50:01 AM 700696 32190488 97.87 2923920 25430416 16681300 95908 0.57 380

Veamos el significado de cada columna:

kbmemfree Memoria libre disponible en KB en ese momento

kbmemused Memoria utilizada en KB en ese momento

%memused % de memoria utilizada

kbbuffers % de memoria utilizado como buffers

kbcached % de memoria utilizado como caché

kbswpfree Espacio de swap libre en KB en ese momento

kbswpused Espacio de swap utilizado en KB en ese momento

%swpused % de swap utilizado en ese momento

kbswpcad Swap en caché en KB en ese momento

Al final del output, usted verá la cifra promedio para el período.

También puede obtener las estadísticas específicas relacionadas con la memoria. La opción -B muestra la actividad relacionada con la paginación.

# sar -BLinux 2.6.9-55.0.9.ELlargesmp (prolin3) 12/27/2008 12:00:01 AM pgpgin/s pgpgout/s fault/s majflt/s12:10:01 AM 134.43 256.63 8716.33 0.0012:20:01 AM 122.05 181.48 8652.17 0.0012:30:01 AM 129.05 253.53 8347.93 0.00... and so on ...

La columna muestra las métricas en ese momento, no las actuales.

pgpgin/s Cantidad de páginas en la memoria desde el disco, por segundo

pgpgout/s Cantidad de páginas fuera del disco, desde la memoria, por segundo

fault/s Fallos de página por segundos

majflt/s Principales fallos de página por segundo

Para obtener un output similar para la actividad relacionada con el swapping, usted puede utilizar la opción -W.

# sar -WLinux 2.6.9-55.0.9.ELlargesmp (prolin3) 12/27/2008 12:00:01 AM pswpin/s pswpout/s12:10:01 AM 0.00 0.0012:20:01 AM 0.00 0.0012:30:01 AM 0.00 0.0012:40:01 AM 0.00 0.00... and so on ...

Las columnas probablemente se explican por si mismas; pero aquí se detalla la descripción de cada una:

pswpin/s Páginas de memoria que vuelven a intercambiarse en la memoria desde el disco, por segundo

pswpout/s

Páginas de la memoria intercambiadas al disco desde la memoria, por segundo

Si usted observa que el nivel de swapping es demasiado elevado, quizás podría estar quedándose sin memoria. No se trata de una conclusión anticipada, sino de una posibilidad.

Para obtener las estadísticas de los dispositivos de disco, utilice la opción -d:

# sar -dLinux 2.6.9-55.0.9.ELlargesmp (prolin3) 12/27/2008 12:00:01 AM DEV tps rd_sec/s wr_sec/s12:10:01 AM dev1-0 0.00 0.00 0.0012:10:01 AM dev1-1 5.12 0.00 219.6112:10:01 AM dev1-2 3.04 42.47 22.2012:10:01 AM dev1-3 0.18 1.68 1.4112:10:01 AM dev1-4 1.67 18.94 15.19... and so on ...Average: dev8-48 4.48 100.64 22.15Average: dev8-64 0.00 0.00 0.00Average: dev8-80 2.00 47.82 5.37Average: dev8-96 0.00 0.00 0.00Average: dev8-112 2.22 49.22 12.08

Aquí está la descripción de las columnas. Nuevamente, ellas muestran las métricas en ese momento.

tps Transferencias por segundo. El término transferencias se refiere a las operaciones I/O. Nota: es solamente la cantidad de operaciones; cada operación puede ser extensa o pequeña. Por lo tanto, esto, por sí mismo, no es la historia completa.

rd_sec/s

Cantidad de sectores leídos desde el disco por Segundo

wr_sec/s

Cantidad de sectores escritos en el disco por Segundo

Para obtener el historial de estadísticas de red, usted puede utilizar la opción -n:

# sar -n DEV | moreLinux 2.6.9-42.0.3.ELlargesmp (prolin3) 12/27/2008 12:00:01 AM IFACE rxpck/s txpck/s rxbyt/s txbyt/s rxcmp/s txcmp/s rxmcst/s12:10:01 AM lo 4.54 4.54 782.08 782.08 0.00 0.00 0.0012:10:01 AM eth0 2.70 0.00 243.24 0.00 0.00 0.00 0.9912:10:01 AM eth1 0.00 0.00 0.00 0.00 0.00 0.00 0.0012:10:01 AM eth2 0.00 0.00 0.00 0.00 0.00 0.00 0.0012:10:01 AM eth3 0.00 0.00 0.00 0.00 0.00 0.00 0.0012:10:01 AM eth4 143.79 141.14 73032.72 38273.59 0.00 0.00 0.9912:10:01 AM eth5 0.00 0.00 0.00 0.00 0.00 0.00 0.0012:10:01 AM eth6 0.00 0.00 0.00 0.00 0.00 0.00 0.0012:10:01 AM eth7 0.00 0.00 0.00 0.00 0.00 0.00 0.0012:10:01 AM bond0 146.49 141.14 73275.96 38273.59 0.00 0.00 1.98… and so on …Average: bond0 128.73 121.81 85529.98 27838.44 0.00 0.00 1.98Average: eth8 0.00 0.00 0.00 0.00 0.00 0.00 0.00Average: eth9 3.52 6.74 251.63 10179.83 0.00 0.00 0.00Average: sit0 0.00 0.00 0.00 0.00 0.00 0.00 0.00

En resumen, usted tiene estas opciones para el comando sar a fin de obtener las métricas para los componentes:

Utilice esta opción … … para obtener estadísticas sobre:

-P CPU(s) Específica(s)

-d Discos

-r Memoria

-B Paginación

-W Intercambio

-n Red

¿Qué sucede si usted desea tener todas las estadísticas disponibles en un solo output? En lugar de invocar sar con todas estas opciones, usted puede utilizar la opción -A que muestra todas las estadísticas almacenadas en los archivos sar.

ConclusiónPara resumir, al utilizar estos grupos de comandos limitados usted puede manejar la mayoría de las tareas que intervienen en la administración de recursos en un entorno Linux. Sugiero que los practique en su entorno a fin de familiarizarse con estos comandos y con las opciones aquí descriptas.

En las próximas entregas, aprenderá cómo monitorear y administrar la red. También aprenderá varios comandos que lo ayudarán a administrar un entorno Linux: para descubrir quién se ha registrado para establecer procesos shell profile, realizar backups utilizando cpio y tar, entre otras cosas.

Guía para Maestría Avanzada en Comandos Linux, Parte 4: Administración del Entorno Linux

por Arup Nanda

Publicado en mayo de 2009

En esta serie, sepa cómo administrar el entorno Linux de manera efectiva a través de estos comandos ampliamente utilizados.

ifconfigEl comando ifconfig muestra los detalles de la/s interfaz/interfaces de red definidas en el sistema. La opción más común es -a , lo cual permite mostrar todas las interfaces.

# ifconfig -a

El nombre usual de la interfaz de red Ethernet primaria es eth0. Para encontrar los detalles de una interfaz específica, por ej., eth0, puede utilizar:

# ifconfig eth0

A continuación se muestra el output con su respectiva explicación:

Éstas son algunas partes claves del output:

• Link encap: corresponde al tipo de medio de hardware físico soportado por esta interfaz (Ethernet, en este caso)

• HWaddr: es el identificador exclusivo de la tarjeta NIC. Cada tarjeta NIC tiene un identificador exclusivo asignado por el fabricante, denominado MAC o dirección MAC. La dirección de IP se adjunta al MAC del servidor. Si esta dirección de IP cambia, o esta tarjeta se mueve desde este servidor a otro, el MAC continúa siendo el mismo.

• Mask: corresponde a la máscara de red • inet addr: es la dirección de IP que se adjunta a la interfaz • RX packets: se refiere a la cantidad de paquetes recibidos por esta interfaz • TX packets: se refiere a la cantidad de paquetes enviados • errors: es la cantidad de errores de envío y recepción

El comando no se utiliza solamente para controlar los parámetros; también se utiliza para configurar y administrar la interfaz. A continuación presentamos un breve listado de los parámetros y opciones de este comando:

up/down – activa o desactiva una interfaz específica. Usted puede utilizar el parámetro down para desconectar una interfaz (o desactivarla):

# ifconfig eth0 down

De manera similar, para conectarla (o activarla), usted debería utilizar:

# ifconfig eth0 up

media – establece el tipo de medio Ethernet como 10baseT, 10 Base 2, etc. Los valores comunes para el parámetro de medios son 10base2, 10baseT, y AUI. Si usted desea que Linux detecte el medio automáticamente, puede especificar “auto”, como se muestra a continuación:

# ifconfig eth0 media auto

add – establece una dirección de IP específica para la interfaz. Para determinar una dirección de IP 192.168.1.101 para la interfaz eth0, usted debería emitir lo siguiente:

# ifconfig eth0 add 192.168.1.101

netmask – determina el parámetro de máscara de red de la interfaz. A continuación se presenta un ejemplo en dónde puede establecer la máscara de red de la interfaz eth0 en 255.255.255.0

# ifconfig eth0 netmask 255.255.255.0

En un entorno Oracle Real Application Clusters usted debe establecer la máscara de red en cierto modo, utilizando este comando.

En algunas configuraciones avanzadas, usted puede cambiar la dirección de MAC asignada a la interfaz de red. El parámetro hw lo hace posible. El formato general es:

ifconfig <Interface> hw <TypeOfInterface> <MAC>

<TypeOfInterface> muestra el tipo de interfaz, por ej., ether, para Ethernet. Aquí se muestra cómo la dirección MAC ha cambiado para eth0 a 12.34.56.78.90.12 (Nota: la dirección MAC que aquí se muestra es ficticia. En caso de ser igual a otra MAC real, es pura coincidencia):

# ifconfig eth0 hw ether 12.34.56.78.90.12

Esto es útil cuando usted agrega una nueva tarjeta (con una nueva dirección MAC) pero no desea cambiar la configuración relacionada con Linux como por ejemplo las interfaces de red.


El comando, junto con nestat descripto anteriormente, es uno de los comandos más frecuentemente utilizados para administrar Oracle RAC. El desempeño de Oracle RAC depende en gran medida de la interconexión utilizada entre los nodos del cluster. Si la interconexión se satura (es decir, que no puede soportar más tráfico adicional) o falla, usted podrá observar una disminución de desempeño. Lo mejor en este caso es observar el output ifconfig para detectar las fallas. Este es un ejemplo típico:

# ifconfig eth9eth9 Link encap:Ethernet HWaddr 00:1C:23:CE:6F:82 inet addr:10.14.104.31 Bcast:10.14.104.255 Mask:255.255.255.0 inet6 addr: fe80::21c:23ff:fece:6f82/64 Scope:Link UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1 RX packets:1204285416 errors:0 dropped:560923 overruns:0 frame:0 TX packets:587443664 errors:0 dropped:623409 overruns:0 carrier:0 collisions:0 txqueuelen:1000 RX bytes:1670104239570 (1.5 TiB) TX bytes:42726010594 (39.7 GiB) Interrupt:169 Memory:f8000000-f8012100

Observe el texto resaltado en rojo. El conteo arrojado es extremadamente elevado; la cantidad ideal debería ser 0 o cercana a 0. Una cantidad mayor a medio millón implicaría una interconexión defectuosa que rechaza los paquetes, provocando que la interconexión los reenvíe—lo cual sería clave para el diagnóstico de problemas.

netstatEl estado input y output a través de una interfaz de red se evalúa por medio del comando netstat. Este comando puede brindar información completa sobre el desempeño de la interfaz de red, incluso por debajo del nivel de socket. Aquí vemos un ejemplo:

# netstatActive Internet connections (w/o servers)Proto Recv-Q Send-Q Local Address Foreign Address State tcp 0 0 prolin1:31027 prolin1:5500 TIME_WAIT tcp 4 0 prolin1l:1521 applin1:40205 ESTABLISHED tcp 0 0 prolin1l:1522 prolin1:39957 ESTABLISHED tcp 0 0 prolin1l:3938 prolin1:31017 TIME_WAITtcp 0 0 prolin1l:1521 prolin1:21545 ESTABLISHED… and so on …

El output de arriba muestra todos los sockets abiertos. En términos más simples, un socket es similar a una conexión entre dos procesos. [Por favor tenga en cuanta que, estrictamente hablando, los conceptos “sockets” y “conexiones” son técnicamente diferentes. Un socket podría existir sin una conexión. De todas maneras, el debate entre sockets y conexiones escapa del alcance de este artículo. Por eso simplemente me limité a presentar el concepto de una manera fácil de comprender]. Naturalmente, una conexión debe tener un origen y un destino, denominados dirección local y remota. Los puntos de destino podrían estar en el mismo servidor o en servidores distintos.

En muchos casos, los programas se conectan al mismo servidor. Por ejemplo, si dos procesos se comunican entre ellos, la dirección local y remota será la misma, como puede observar en la primera línea –tanto la dirección local como la remota corresponden al servidor “prolin1”. No obstante, los procesos se comunican a través de un puerto, que es diferente. El puerto se muestra luego del nombre de host, después de los dos puntos “:”. El programa del usuario envía los datos que deben remitirse a través del socket a una cola y el receptor los lee desde la cola de destino remoto. Éstas son las columnas del output:

1. la columna del extremo izquierdo denominada “Proto” muestra el tipo de conexión – tcp en este caso.

2. La columna Recv-Q muestra los bytes de datos en cola a ser enviados al programa del usuario que estableció la conexión. Este valor debería ser un valor cercano a 0, preferentemente. En los servidores ocupados este valor será mayor a 0 pero no debería ser demasiado alto. Una cantidad mayor no podría significar mucho, a menos que observe una cantidad elevada en la columna Send-Q, descripta a continuación.

3. La columna Send-Q denota los bytes en cola a ser enviados al programa remoto, es decir, el programa remoto aún no ha confirmado su recepción. Esta cantidad debería ser cercana a 0. Una cantidad mayor podría indicar un cuello de botella en la red.

4. Local Address se refiere al origen de la conexión y el número de puerto del programa. 5. Foreign Address hace referencia al host de destino y el número de puerto. En la primera

línea, tanto el origen como el destino corresponden al mismo host: prolin1. La conexión se encuentra simplemente en espera. La segunda línea muestra una conexión establecida entre el puerto 1521 de proiln1 hasta el puerto 40205 del host applin1. Lo más probable es que una conexión de Oracle venga del applin1 cliente hasta el servidor prolin1. El listener de Oracle en prolin1 se ejecuta en el puerto 1521; de manera que el puerto de origen es 1521. En esta conexión, el servidor envía los datos solicitados al cliente.

6. La columna State muestra el estado de la conexión. Aquí vemos algunos valores comunes. ESTABLISHED – implica que la conexión ha sido establecida. No significa que los

datos fluyen entre los puntos de destino; simplemente que se ha establecido una comunicación entre ellos.

CLOSED – la conexión se ha cerrado, es decir, no está siendo utilizada. TIME_WAIT – la conexión se está cerrando pero aún hay paquetes pendientes en la

red. CLOSE_WAIT – el destino remoto ha sido cerrado y se ha solicitado el cierre de

conexión.

Pues bien, a partir de las direcciones locales (local) y externas (foreign), y especialmente a partir de los números de puertos, probablemente podamos deducir que las conexiones son conexiones relacionadas a Oracle, pero ¿no sería mejor estar seguros? Por supuesto. La opción -p también muestra la información del proceso:

# netstat -pProto Recv-Q Send-Q Local Address Foreign Address State PID/Program name tcp 0 0 prolin1:1521 prolin1:33303 ESTABLISHED 1327/oraclePROPRD1

tcp 0 0 prolin1:1521 applin1:51324 ESTABLISHED 13827/oraclePROPRD1 tcp 0 0 prolin1:1521 prolin1:33298 ESTABLISHED 32695/tnslsnr tcp 0 0 prolin1:1521 prolin1:32544 ESTABLISHED 15251/oracle+ASM tcp 0 0 prolin1:1521 prolin1:33331 ESTABLISHED 32695/tnslsnr

Esto muestra claramente el IP del proceso y el nombre del proceso en la última columna, la cual confirma que corresponden a procesos del servidor de Oracle, al proceso listener, y a los procesos del servidor ASM.

El comando netstat puede presentar varias opciones y parámetros. A continuación se detallan los más importantes:

Para ver las estadísticas de red de las distintas interfaces, utilice la opción -i.

# netstat -iKernel Interface tableIface MTU Met RX-OK RX-ERR RX-DRP RX-OVR TX-OK TX-ERR TX-DRP TX-OVR Flgeth0 1500 0 6860659 0 0 0 2055833 0 0 0 BMRUeth8 1500 0 2345 0 0 0 833 0 0 0 BMRUlo 16436 0 14449079 0 0 0 14449079 0 0 0 LRU

Esto muestra las distintas interfaces presentes en el servidor (eth0, eth8, etc.) y las métricas relacionadas con la interfaz.

• RX-OK muestra la cantidad de paquetes que son exitosamente enviados (para esta interfaz) • RX-ERR muestra la cantidad de errores • RX-DRP muestra los paquetes rechazados que debieron ser reenviados (ya sea con éxito o

no) • RX-OVR muestra un exceso de paquetes

El próximo grupo de columnas (TX-OK, TX-ERR, etc.) muestra las stats (estadísticas) correspondientes a los datos enviados.

La columna Flg expresa un valor compuesto de la propiedad de la interfaz. Cada letra indica una propiedad específica presente. A continuación se detalla el significado de las letras.

B – Broadcasting (Difusión) M –Multicast (Multidifusión) R – Running (En ejecución)U – Up (Activado)O – ARP Off (ARP desactivado)P – Point to Point Connection (Conexión Punto a Punto)L – Loopback (Circuito cerrado)m – Master s - Slave

Usted pude utilizar la opción --interface (nota: hay dos guiones, no uno) para desplegar una interfaz específica.

# netstat --interface=eth0 Kernel Interface table

Iface MTU Met RX-OK RX-ERR RX-DRP RX-OVR TX-OK TX-ERR TX-DRP TX-OVR Flgeth0 1500 0 277903459 0 0 0 170897632 0 0 0 BMsRU

De más está decir que, el output es amplio y un poco difícil de captar de un solo intento. Si usted está realizando una comparación entre interfaces, sería lógico tener un output tabular. Si desea examinar los valores en un formato más legible, utilice la opción -e para producir un output extendido:

# netstat -i -eKernel Interface tableeth0 Link encap:Ethernet HWaddr 00:13:72:CC:EB:00 inet addr:10.14.106.0 Bcast:10.14.107.255 Mask:255.255.252.0 inet6 addr: fe80::213:72ff:fecc:eb00/64 Scope:Link UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1 RX packets:6861068 errors:0 dropped:0 overruns:0 frame:0 TX packets:2055956 errors:0 dropped:0 overruns:0 carrier:0 collisions:0 txqueuelen:1000 RX bytes:3574788558 (3.3 GiB) TX bytes:401608995 (383.0 MiB) Interrupt:169

¿El output le resulta conocido? Debería ser así ya que es el mismo que el output de ifconfig.

Si prefiere que el output despliegue las direcciones de IP en lugar de los nombres del host, utilice la opción -n.

La opción -s muestra el resumen de estadísticas de cada protocolo, en vez de mostrar los detalles de cada conexión. Esto puede combinarse con el flag específico del protocolo, Por ejemplo, -u muestra las estadísticas relacionadas con el protocolo UDP.

# netstat -s -uUdp: 12764104 packets received 600849 packets to unknown port received. 0 packet receive errors 13455783 packets sent

Del mismo modo, para ver las stats de tcp, utilice -t y para raw, -r.

Una de las opciones realmente útiles es desplegar la tabla de ruta, utilizando la opción -r.

# netstat -rKernel IP routing tableDestination Gateway Genmask Flags MSS Window irtt Iface10.20.191.0 * 255.255.255.128 U 0 0 0 bond0172.22.13.0 * 255.255.255.0 U 0 0 0 eth9169.254.0.0 * 255.255.0.0 U 0 0 0 eth9default 10.20.191.1 0.0.0.0 UG 0 0 0 bond0

La segunda columna del output netstat –Gateway–muestra el gateway de asignación de ruta. Si no se utiliza ningún gateway, aparece un asterisco. La tercera columna–Genmask–muestra la “generalidad” del enrutamiento, es decir, la máscara de red para esta ruta. Al dar una dirección de IP para encontrar una ruta adecuada, el kernel sigue el proceso de cada una de las entradas de enrutamiento, tomando el nivel de bits AND de la dirección y la máscara de red antes de compararlo con el destino de ruta.

La cuarta columna, denominada Flags, despliega las siguientes etiquetas que describen la ruta:

• G significa que la ruta utiliza un gateway.

• U implica que la interfaz a ser utilizada se encuentra activa (disponible). • H implica que solo puede alcanzarse un único host a través de la ruta. Por ejemplo, el caso

de la entrada de loopback (circuito cerrado) 127.0.0.1. • D significa que esta ruta ha sido dinámicamente creada. • ! significa que la ruta ha sido rechazada y se descartarán los datos.

La siguientes tres columnas muestran los valores MSS, Window e irtt que se aplicarán a las conexiones TCP establecidas por medio de esta ruta.

• MSS representa la sigla Maximum Segment Size (Tamaño de Segmento Máximo) –es el tamaño del datagrama más amplio para realizar la transmisión a través de esta ruta.

• Window se refiere a la cantidad máxima de datos que el sistema aceptará en modo single burst desde un host remoto y para esta ruta.

• irtt representa la sigla de Initial Round Trip Time (el Valor Inicial del Temporizador TCP). Es un poco difícil de explicar, pero lo haré por separado.

El protocolo TCP posee un control de fiabilidad incorporado. Si un paquete de datos falla durante la transmisión, éste es retransmitido. El protocolo lleva un registro de cuánto tiempo tardan los datos en llegar a destino y en confirmarse su recepción. Si la confirmación no llega dentro de ese plazo de tiempo, el paquete es retransmitido. La cantidad de tiempo que el protocolo debe esperar antes de retransmitir los datos se establece solo una vez para la interfaz (la cual puede cambiarse) y ese valor es conocido como initial round trip time. Un valor de 0 implica que el valor por defecto es utilizado.

Finalmente, el último campo despliega la interfaz de red que utilizará esta ruta.

nslookupCada host accesible en una red debería tener una dirección de IP que le permita identificarse exclusivamente en la red. En Internet, que es una red extensa, las direcciones de IP permiten que las conexiones lleguen a los servidores que ejecutan sitios Web, por ej., www.oracle.com. Por lo tanto, cuando un host (como un cliente) desea conectarse a otro (como un servidor de base de datos) utilizando su nombre y no su dirección de IP ¿cómo el browser cliente sabe a qué dirección conectarse?

El mecanismo de traspaso del nombre de host a las direcciones de IP es conocido como resolución de nombre. En el nivel más rudimentario, el host tiene un archivo especial denominado hosts, que almacena la Dirección de IP – Hostname. Este es un archivo de muestra:

# cat /etc/hosts# Do not remove the following line, or various programs# that require network functionality will fail.127.0.0.1 localhost.localdomain localhost192.168.1.101 prolin1.proligence.com prolin1192.168.1.102 prolin2.proligence.com prolin2

Esto muestra que el nombre del host prolin1.proligence.com se traduce a 192.168.1.101. La entrada especial con la dirección de IP 127.0.0.1 se denomina entrada loopback, la cual vuelve al servidor mismo por medio de una interfaz de red especial denominada lo (que se menciona anteriormente en los comandos ifconfig y netstat).

Ahora bien, de todas formas, usted posiblemente no puede colocar todas las direcciones de IP del mundo en este archivo. Por lo que debería haber otro mecanismo que establezca la resolución del nombre. Un servidor con un propósito especial denominado nameserver realiza esa función. Es como un directorio que provee su compañía telefónica; no su directorio personal. Pueden existir

varios nameservers disponibles dentro y fuera de la red privada. El host contacta a uno de estos nameservers primero, obtiene la dirección de IP del host de destino que desea contactar y luego intenta conectarse a la dirección de IP.

¿Y cómo el host sabe cuáles son estos nameservers? Busca en un archivo especial llamado /etc/resolv.conf para obtener esa información. Aquí vemos un archivo resolv de ejemplo.

; generated by /sbin/dhclient-scriptsearch proligence.comnameserver 10.14.1.58nameserver 10.14.1.59nameserver 10.20.223.108

¿Pero cómo podemos estar seguros de que la resolución del nombre está funcionando perfectamente para un nombre de host específico? En otras palabras, usted quiere asegurarse de que cuando el sistema de Linux intente contactarse a un host denominado oracle.com, pueda encontrar la dirección de IP en el nameserver. El comando nslookup es útil para eso. Vea a continuación cómo utilizarlo:

# nslookup oracle.comServer: 10.14.1.58Address: 10.14.1.58#53

** server can't find oracle-site.com: NXDOMAIN

Analicemos el output. El output del Server (Servidor) es la dirección del nameserver. El nombre oracle.com establece la dirección de IP 141.146.8.66. El nombre fue definido por el nameserver próximo a la palabra Server en el output.

Si usted escribe esta dirección de IP en un browser–http://141.146.8.66 en lugar de http://oracle.com--el browser se dirigirá al sitio oracle.com.

Si usted cometió un error o buscó un host equivocado:

# nslookup oracle-site.comServer: 10.14.1.58Address: 10.14.1.58#53

** server can't find oracle-site.com: NXDOMAIN

El mensaje es bastante claro: este host no existe.

digEl comando nslookup ha caído en desuso. En su lugar debería utilizarse un comando nuevo y más poderoso – dig (domain information groper). En algunos servidores Linux más nuevos, el comando nslookup podría no estar aún disponible.

Aquí vemos un ejemplo; para verificar la resolución del nombre del host oracle.com, debería utilizar el siguiente comando:

# dig oracle.com

; <<>> DiG 9.2.4 <<>> oracle.com;; global options: printcmd;; Got answer:;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 62512;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 8, ADDITIONAL: 8 ;; QUESTION SECTION:;oracle.com. IN A

;; ANSWER SECTION:oracle.com. 300 IN A 141.146.8.66 ;; AUTHORITY SECTION:oracle.com. 3230 IN NS ns1.oracle.com.oracle.com. 3230 IN NS ns4.oracle.com.oracle.com. 3230 IN NS u-ns1.oracle.com.oracle.com. 3230 IN NS u-ns2.oracle.com.oracle.com. 3230 IN NS u-ns3.oracle.com.oracle.com. 3230 IN NS u-ns4.oracle.com.oracle.com. 3230 IN NS u-ns5.oracle.com.oracle.com. 3230 IN NS u-ns6.oracle.com. ;; ADDITIONAL SECTION:ns1.oracle.com. 124934 IN A 148.87.1.20ns4.oracle.com. 124934 IN A 148.87.112.100u-ns1.oracle.com. 46043 IN A 204.74.108.1u-ns2.oracle.com. 46043 IN A 204.74.109.1u-ns3.oracle.com. 46043 IN A 199.7.68.1u-ns4.oracle.com. 46043 IN A 199.7.69.1u-ns5.oracle.com. 46043 IN A 204.74.114.1u-ns6.oracle.com. 46043 IN A 204.74.115.1 ;; Query time: 97 msec;; SERVER: 10.14.1.58#53(10.14.1.58);; WHEN: Mon Dec 29 22:05:56 2008;; MSG SIZE rcvd: 328

Desde el output mammoth, se destacan varias cosas. Muestra que el comando ha enviado una consulta al nameserver y el host obtuvo una respuesta del nameserver. La resolución del nombre también ha sido efectuada en otros nameservers como ns1.oracle.com. Esto demuestra que la consulta tardó 97 milisegundos en ejecutarse.

Si el tamaño del output no es el adecuado, usted puede utilizar la opción +short para eliminar las palabras redundantes del output:

# dig +short oracle.com141.146.8.66

También puede utilizar la dirección de IP para realizar una búsqueda inversa del nombre de host a partir de la dirección de IP. Para esto se utiliza la opción -x.

# dig -x 141.146.8.66

El parámetro +domain es útil cuando usted busca un host dentro de un dominio. Por ejemplo, supongamos que usted está buscando el host otn en el dominio oracle.com, usted puede utilizar:

# dig +short otn.oracle.com

O puede utilizar el parámetro +domain:

# dig +short +tcp +domain=oracle.com otnwww.oracle.com.www.oraclegha.com.141.146.8.66


Se establece la conectividad entre el servidor de aplicaciones y el servidor de base de datos. El

archivo TNSNAMES.ORA, utilizado por SQL*Net puede parecerse a este:

prodb3 = (description = (address_list = (address = (protocol = tcp)(host = prolin3)(port = 1521)) ) (connect_data = (sid = prodb3) ) )

El nombre de host prolin3 debería ser determinado por el servidor de aplicaciones. En cualquiera de los casos, éste debería figurar en el archivo /etc/hosts; o el host prolin3 debería definirse en el DNS. Para asegurarse de que la resolución del nombre funciona, y que funciona de manera correcta para dirigirse al host adecuado, usted puede utilizar el comando dig.

Con estos dos comandos usted puede manejar la mayoría de las tareas de red en un entorno Linux. En la que queda de esta presentación, usted aprenderá a administrar un entorno Linux de manera efectiva.

uptimeUsted ha ingresado al servidor y ha observado que algunas cosas que deberían estar funcionando, en verdad no lo están. Tal vez algunos procesos fueron cancelados o quizás todos los procesos han sido finalizados debido a un cierre del sistema. En lugar de hacer suposiciones, descubra si el servidor ha sido realmente reiniciado utilizando el comando uptime. El comando muestra el plazo de tiempo durante el cual el servidor ha estado funcionando desde su último reinicio.

# uptime 16:43:43 up 672 days, 17:46, 45 users, load average: 4.45, 5.18, 5.38

El output muestra mucha información de utilidad. La primera columna muestra el momento real en que el comando fue ejecutado. La segunda parte – activo 672 días, 17:46 – muestra el tiempo en que el servidor ha estado activo. Las cifras 17:46 representan las horas y minutos. Por lo tanto, este servidor ha estado funcionando por 672 días, 17 horas y 46 minutos hasta el momento.

El siguiente elemento – 45 usuarios – muestra la cantidad de usuarios que han iniciado sesión en el servidor justo en ese momento.

Los últimos bits del output muestran el promedio de carga del servidor en el último minuto, y en los último 5 y 15 minutos respectivamente. El término “carga promedio” es una cifra compuesta que representa la carga del sistema sobre la base de las métricas de I/O y CPU. Cuanto mayor es el promedio de carga, mayor la carga en el sistema. No se basa en una escala; a diferencia de los porcentajes, no finaliza con una cantidad determinada, como 100. Además, la carga promedio de dos sistemas no puede compararse entre sí. Dicha cifra se utiliza para cuantificar la carga en un sistema y solo es relevante para ese único sistema. Este output muestra que la carga promedio fue de 4,45 en el último minuto, 5,18 en los últimos 5 minutos y así sucesivamente.

El comando no tiene ninguna opción ni acepta ningún parámetro que no sea -V, el cual muestra la versión del comando.

# uptime -Vprocps version 3.2.3


No existe un uso específico de Oracle en torno a este comando, salvo que usted puede conocer la carga del sistema para explicar algunos problemas de desempeño. Si observa algunos problemas de desempeño en la base de datos, y éstos surgen debido a la elevada carga de I/O o CPU, usted inmediatamente debería controlar las cargas promedio utilizando el comando uptime. Si observa un promedio de carga elevado, su próximo paso será realizar un examen detallado para detectar la causa del problema. Para realizar este análisis, usted cuenta con una gran cantidad de herramientas como mpstat, iostat y sar (descriptas en esta presentación de la serie).

Preste atención al output que se muestra a continuación:

# uptime 21:31:04 up 330 days, 7:16, 4 users, load average: 12.90, 1.03, 1.00

Es interesante ver cómo el promedio de carga era bastante elevado (12,90) en el último minuto y luego ha disminuido bastante, incluso hasta niveles irrelevantes, llegando a 1,03 y 1,00 en los últimos 5 y 15 minutos respectivamente. ¿Qué significa esto? Esto demuestra que en menos de 5 minutos, se inició algún proceso que provocó que el promedio de carga subiera repentinamente en el último minuto. Este proceso no estaba presente anteriormente ya que el promedio de carga era bastante bajo. Este análisis nos lleva a concentrarnos en los procesos iniciados en los últimos minutos – acelerando así el proceso de resolución.

Lógicamente, como esto demuestra la cantidad de tiempo en que el servidor ha estado funcionando, también explica por qué la instancia ha estado activa desde aquel momento.

who¿Quién ha ingresado en el sistema en este momento? Esa es una simple pregunta que usted podría hacerse especialmente si desea rastrear a algún usuario errante que está ejecutando algunos comandos que consumen recursos.

El comando who responde esa pregunta. Observe aquí el uso más simple de este comando, sin argumentos ni parámetros.

# whooracle pts/2 Jan 8 15:57 (10.14.105.139)oracle pts/3 Jan 8 15:57 (10.14.105.139)root pts/1 Dec 26 13:42 (:0.0)root :0 Oct 23 15:32

El comando puede presentar varias opciones. La opción -s es la opción por defecto; que produce el mismo output que arriba.

Observando el output, usted quizás esté haciendo memoria para recordar lo que significan las columnas. Bueno, relájese. Puede utilizar la opción -H para desplegar el encabezado:

# who -HNAME LINE TIME COMMENToracle pts/2 Jan 8 15:57 (10.14.105.139)oracle pts/3 Jan 8 15:57 (10.14.105.139)root pts/1 Dec 26 13:42 (:0.0)root :0 Oct 23 15:32

Ahora el significado de las columnas es claro. La columna NAME muestra el nombre de usuario registrado. LINE muestra el nombre de terminal. En Linux cada conexión se denomina como una terminal con el convenio de denominación pts/<n> en donde <n> es un número que comienza con 1. La terminal :0 es una denominación para la terminal X. TIME muestra la primera vez en que se

registraron. Y COMMENTS muestra la dirección de IP desde donde se registraron.

¿Pero qué sucede si usted solo quiere obtener un listado con los nombres de usuarios en lugar de ver todos esos detalles superfluos? La opción -q logra eso. Despliega los nombres de usuarios en una sola línea, ordenados alfabéticamente. También despliega la cantidad total de usuarios al final (45, en este caso):

# who -qananda ananda jsmith klome oracle oracle root root … and so on for 45 names# users=45

Algunos usuarios podrían haber iniciado sesión pero no estar realizando ninguna actividad en realidad. Usted puede controlar por cuánto tiempo han estado inactivos utilizando la opción -u, lo cual es realmente útil, especialmente si usted es el jefe.

# who -uHNAME LINE TIME IDLE PID COMMENToracle pts/2 Jan 8 15:57 . 18127 (10.14.105.139)oracle pts/3 Jan 8 15:57 00:26 18127 (10.14.105.139)root pts/1 Dec 26 13:42 old 6451 (:0.0)root :0 Oct 23 15:32 ? 24215

La nueva columna IDLE muestra el tiempo de inactividad con el formato hh:mm. ¿Observa el valor “old” en esa columna? Implica que el usuario ha estado inactivo durante más de 1 día. La columna PID muestra el ID del proceso de su conexión shell.

Otra opción útil es -b que muestra cuando el sistema ha sido reiniciado.

# who -b system boot Feb 15 13:31

Muestra que el sistema ha sido reiniciado el 15 de febrero a la 1:31 p.m. ¿Recuerda el comando uptime? También muestra la cantidad de tiempo durante el cual el sistema ha estado activo. Usted puede restar los días que se observan en uptime para saber la fecha de reinicio. El comando -b facilita esto ya que directamente muestra la fecha de reinicio.

Advertencia Importante: El comando who -b muestra el mes y la fecha únicamente, no el año. De modo que si el sistema ha estado activo por más de un año, el output no reflejará el valor correcto. Por consiguiente el comando uptime siempre es el enfoque preferido, incluso si usted tiene que hacer algunos cálculos. Aquí vemos un ejemplo:

# uptime 21:37:49 up 675 days, 22:40, 1 user, load average: 3.35, 3.08, 2.86# who -b system boot Mar 7 22:58

Observe que la fecha de reinicio es el 7 de marzo. Eso fue en 2007 ¡no en 2008! El uptime muestra la fecha correcta – ha estado activo durante 675 días. Si las restas no son su fuerte, puede utilizar un simple SQL para obtener esa fecha, 675 días atrás:

SQL> select sysdate - 675 from dual;

SYSDATE-6---------07-MAR-07

La opción -l muestra los inicios de sesión al sistema:

# who -lH

NAME LINE TIME IDLE PID COMMENTLOGIN tty1 Feb 15 13:32 4081 id=1LOGIN tty6 Feb 15 13:32 4254 id=6

Para descubrir las terminales del usuario que ya no están en uso, utilice la opción -d:

# who -dHNAME LINE TIME IDLE PID COMMENT EXIT Feb 15 13:31 489 id=si term=0 exit=0 Feb 15 13:32 2870 id=l5 term=0 exit=0 pts/1 Oct 10 14:53 31869 id=ts/1 term=0 exit=0 pts/4 Jan 11 00:20 22155 id=ts/4 term=0 exit=0 pts/3 Jun 29 16:01 0 id=/3 term=0 exit=0 pts/2 Oct 4 22:35 8371 id=/2 term=0 exit=0 pts/5 Dec 30 03:15 5026 id=ts/5 term=0 exit=0 pts/4 Dec 30 22:35 0 id=/4 term=0 exit=0

Algunas veces el proceso init (el proceso que primero se ejecuta cuando se reinicia el sistema) inicia otros procesos. La opción -p muestra todos esos inicios de sesión que están activos.

# who -pHNAME LINE TIME PID COMMENT Feb 15 13:32 4083 id=2 Feb 15 13:32 4090 id=3 Feb 15 13:32 4166 id=4 Feb 15 13:32 4174 id=5 Feb 15 13:32 4255 id=x Oct 4 23:14 13754 id=h1

Más adelante en este documento, usted conocerá un comando – write – que permite enviar y recibir mensajes en tiempo real. También aprenderá a desactivar la capacidad de otros para escribir en su terminal (el comando mesg). Si desea saber qué usuarios permiten y no permiten a los demás escribir en sus terminales, utilice la opción -T:

# who -THNAME LINE TIME COMMENToracle + pts/2 Jan 11 12:08 (10.23.32.10)oracle + pts/3 Jan 11 12:08 (10.23.32.10)oracle - pts/4 Jan 11 12:08 (10.23.32.10)root + pts/1 Dec 26 13:42 (:0.0)root ? :0 Oct 23 15:32

El signo + sign antes del nombre de la terminal implica que la terminal acepta los comandos de escritura de otros; el signo “-” significa que la terminal no lo permite. El signo “?” en este campo significa que la terminal no soporta escrituras, por ejemplo, una sesión X-window.

El nivel actual de ejecución del sistema puede obtenerse a través de la opción -r:

# who -rHNAME LINE TIME IDLE PID COMMENT run-level 5 Feb 15 13:31 last=S

Con la opción -a (all) puede obtenerse un listado más descriptivo. Esta opción combina las opciones -b -d -l -p -r -t -T -u. De modo que estos dos comandos producen el mismo resultado:

# who -bdlprtTu# who -a

Aquí vemos un output de muestra (con el encabezado, para que usted puede comprender mejor las columnas):

# who -aH

NAME LINE TIME IDLE PID COMMENT EXIT Feb 15 13:31 489 id=si term=0 exit=0 system boot Feb 15 13:31 run-level 5 Feb 15 13:31 last=S Feb 15 13:32 2870 id=l5 term=0 exit=0LOGIN tty1 Feb 15 13:32 4081 id=1 Feb 15 13:32 4083 id=2 Feb 15 13:32 4090 id=3 Feb 15 13:32 4166 id=4 Feb 15 13:32 4174 id=5LOGIN tty6 Feb 15 13:32 4254 id=6 Feb 15 13:32 4255 id=x Oct 4 23:14 13754 id=h1 pts/1 Oct 10 14:53 31869 id=ts/1 term=0 exit=0oracle + pts/2 Jan 8 15:57 . 18127 (10.14.105.139)oracle + pts/3 Jan 8 15:57 00:18 18127 (10.14.105.139) pts/4 Dec 30 03:15 5026 id=ts/4 term=0 exit=0 pts/3 Jun 29 16:01 0 id=/3 term=0 exit=0root + pts/1 Dec 26 13:42 old 6451 (:0.0) pts/2 Oct 4 22:35 8371 id=/2 term=0 exit=0root ? :0 Oct 23 15:32 ? 24215 pts/5 Dec 30 03:15 5026 id=ts/5 term=0 exit=0 pts/4 Dec 30 22:35 0 id=/4 term=0 exit=0

Para ver su propio inicio de sesión, utilice la opción -m:

# who -moracle pts/2 Jan 8 15:57 (10.14.105.139)

¿Observa el valor pts/2? Es el número de terminal. Usted puede encontrar su propia terminal a través del comando tty:

# tty/dev/pts/2

En Linux existe una estructura de comando especial para mostrar su propio registro de inicio de sesión –who am i. Produce el mismo output como en la opción -m.

# who am ioracle pts/2 Jan 8 15:57 (10.14.105.139)

Los únicos argumentos permitidos son “am i" y “mom likes” (¡si, aunque no lo crea!). Ambos producen el mismo output,

Original Instant Messenger SystemCon la llegada de la mensajería instantánea o los programas de chat quedó comprobado que hemos conquistado el desafío global de mantener un intercambio de información en tiempo real, sin olvidarnos de las comunicaciones de voz. ¿Pero estos programas solo se encuentran en el ámbito de los llamados programas atractivos?

El concepto de chat o mensajería instantánea ha estado disponible durante bastante tiempo en *nix. De hecho, usted tiene un sistema IM seguro y completo incorporado en Linux. Éste le permite conversar de manera segura con cualquier persona conectada al sistema; sin requerir conexión de internet. El chat es activado a través de los comandos – write, mesg, wall y talk. Examinemos cada uno de ellos.

El comando write permite escribir en la terminal de un usuario. Si el usuario ha iniciado sesión en más de una terminal, usted puede dirigirse a una dirección específica. Aquí se muestra cómo

escribir el mensaje “Cuidado con el virus” para el usuario “oracle” que inició sesión en la terminal “pts/3”:

# write oracle pts/3Beware of the virusttyl <Control-D>#

La combinación de teclas Control-D finaliza el mensaje, devuelve el shell prompt (#) al usuario final y lo envía a la terminal del usuario. Cuando éste se envía, el usuario “oracle” verá en la terminal pts/3 los mensajes:

Beware of the virusttyl

Cada línea aparecerá a medida que el remitente presione ENTER después de las líneas. Cuando el remitente presiona Control-D, finalizando la transmisión, el receptor verá EOF en la pantalla. El mensaje se desplegará independientemente de la actual acción del usuario. Si el usuario está editando un archivo en vi, el mensaje aparece y el usuario puede eliminarlo al presionar Control-L. Si el usuario se encuentra en SQL*Plus prompt, el mensaje aún aparece pero no afecta los registros del teclado del usuario.

¿Pero qué sucede si usted no quiere sufrir estas pequeñas molestias? Usted no quiere que nadie le envíe mensajes del tipo –“descuelga el teléfono”. Usted puede hacerlo a través del comando mesg. Este comando desactiva la capacidad de los demás para enviarle mensajes. El comando sin ningún argumento muestra la siguiente capacidad:

# mesgis y

Muestra que otros pueden escribirle. Para desactivarlo:

# mesg n

Ahora para confirmar:

# mesg is n

Cuando usted intenta escribir en las terminales de los usuarios, quizás desee saber qué terminales han sido desactivadas para que otros no puedan escribir en ellas. El comando -T (descripto anteriormente en este documento) muestra que:

# who -THNAME LINE TIME COMMENToracle + pts/2 Jan 11 12:08 (10.23.32.10)oracle + pts/3 Jan 11 12:08 (10.23.32.10)oracle - pts/4 Jan 11 12:08 (10.23.32.10)root + pts/1 Dec 26 13:42 (:0.0)root ? :0 Oct 23 15:32

El signo + antes del nombre de terminal indica que ésta acepta escribir comandos de otros; el signo “-“ indica que esto no está permitido. El signo “?” indica que la terminal no soporta escrituras en ella, por ej., una sesión X-window.

¿Y qué ocurre cuando usted desea escribir a todos los usuarios que han iniciado sesión? En lugar de tipear cada uno, utilice el comando wall:

# wallhello everyone

Una vez que se envía, aparece el siguiente texto en las terminales de todos los usuarios que han iniciado sesión:

Broadcast message from oracle (pts/2) (Thu Jan 8 16:37:25 2009):

hello everyone

Esto es muy útil para los usuarios root. Cuando usted quiere cerrar el sistema, desmontar un sistema de archivos, o realizar funciones administrativas similares, quizás desee que todos los usuarios cierren su sesión. Utilice el comando para enviar un mensaje a todos.

Finalmente, el programa talk le permite conversar en tiempo real. Simplemente tipee lo siguiente

# talk oracle pts/2

Si desea conversar con algún usuario en un servidor diferente – prolin2 –puede utilizar

# talk oracle@prolin2 pts/2

Esto abre una ventana de conversación en la otra terminal y ahora usted puede conversar con esa persona en tiempo real. ¿Es esto distinto a cualquier otro programa de conversación “profesional” que actualmente utiliza? Probablemente no. A propósito, para que la conversación funcione correctamente, asegúrese de que el talkd daemon esté ejecutándose, ya que éste podría estar desinstalado.

wSi, es un comando ¡a pesar de que tenga solo una letra! El comando w es una combinación de los comandos uptime y who ejecutados uno inmediatamente luego del otro, en ese orden. Veamos un output muy común sin argumentos ni opciones.

# w 17:29:22 up 672 days, 18:31, 2 users, load average: 4.52, 4.54, 4.59USER TTY FROM LOGIN@ IDLE JCPU PCPU WHAToracle pts/1 10.14.105.139 16:43 0.00s 0.06s 0.01s woracle pts/2 10.14.105.139 17:26 57.00s 3.17s 3.17s sqlplus as sysdba… and so on …

El output tiene dos partes distintas. La primera parte muestra el output del comando uptime (descripto arriba en este documento) el cual muestra el tiempo en que el servidor ha esta activo, cuantos usuarios han iniciado sesión y el promedio de carga en el último minuto y en los últimos 5 y 15 minutos. Las partes del output han sido explicadas en el comando uptime. La segunda parte del output muestra el output del comando who con la opción -H (también explicado en este documento). Nuevamente, las numerosas columnas también han sido explicadas en el comando who.

Si usted prefiere no desplegar el encabezado, utilice la opción -h.

# w -horacle pts/1 10.14.105.139 16:43 0.00s 0.02s 0.01s w -h

Esto elimina el encabezado del output. Es útil en los shell scripts en donde quiere leer y actuar en base al output sin la carga adicional de saltear el encabezado.

La opción -s produce una versión compacta (corta) del output, eliminando el tiempo de inicio de sesión, y los tiempos de JPCU y PCPU.

# w -s 17:30:07 up 672 days, 18:32, 2 users, load average: 5.03, 4.65, 4.63

USER TTY FROM IDLE WHAToracle pts/1 10.14.105.139 0.00s w -soracle pts/2 10.14.105.139 1:42 sqlplus as sysdba

Usted podría encontrar que el campo “FROM” realmente no es muy útil. Muestra la dirección de IP del mismo servidor, ya que los registros de inicio de sesión son todos locales. Para ahorrar espacio en el output, usted podría suprimir este campo. La opción -f desactiva la impresión del campo FROM:

# w -f 17:30:53 up 672 days, 18:33, 2 users, load average: 4.77, 4.65, 4.63USER TTY LOGIN@ IDLE JCPU PCPU WHAToracle pts/1 16:43 0.00s 0.06s 0.00s w -foracle pts/2 17:26 2:28 3.17s 3.17s sqlplus as sysdba

El comando acepta solo un parámetro: el nombre de un usuario. Por defecto muestra el proceso e inicio de sesión de todos los usuarios. Si usted coloca el nombre de usuario, se muestra el registro de inicio de sesión de ese usuario solamente. Por ejemplo, para mostrar solo el inicio de sesión de los usuarios root, debe emitir:

# w -h rootroot pts/1 :0.0 26Dec08 13days 0.01s 0.01s bashroot :0 - 23Oct08 ?xdm? 21:13m 1.81s /usr/bin/gnome-session

La opción -h fue utilizada para ocultar el encabezado.

killUn proceso se está ejecutando y usted desea que el proceso finalice. ¿Qué debería hacer? El proceso se ejecuta en un segundo plano, de modo que no necesita ir a la terminal y presionar Control-C; o, tal vez el proceso pertenece a otro usuario (utilizando el mismo userid, como “oracle”) y usted desea que termine. El comando kill justamente va al rescate; hace lo que su nombre sugiere – finaliza el proceso. Su uso más común es:

# kill <Process ID of the Linux process>

Supongamos que usted quiere finalizar un proceso denominado sqlplus emitido por el usuario oracle, usted debe conocer su processid, o PID:

# ps -aef|grep sqlplus|grep anandaoracle 8728 23916 0 10:36 pts/3 00:00:00 sqlplusoracle 8768 23896 0 10:36 pts/2 00:00:00 grep sqlplus

Ahora para finalizar el PID 8728:

# kill 8728

Y así se finaliza el proceso. Por supuesto usted debe ser el mismo usuario (oracle) para finalizar un proceso iniciado por oracle. Para finalizar procesos iniciados por otros usuarios usted debe ser un super usuario – root.

Algunas veces usted puede querer simplemente detener el proceso en vez de finalizarlo. Puedo utilizar la opción -SIGSTOP con el comando kill.

# kill -SIGSTOP 9790# ps -aef|grep sqlplus|grep oracleoracle 9790 23916 0 10:41 pts/3 00:00:00 sqlplus as sysdbaoracle 9885 23896 0 10:41 pts/2 00:00:00 grep sqlplus

Esto es útil para los trabajos que se realizan en segundo plano pero con procesos de primer plano. Simplemente detiene el proceso y le quita el control al usuario. De modo que, si usted verifica el proceso nuevamente luego de emitir el comando:

# ps -aef|grep sqlplus|grep oracleoracle 9790 23916 0 10:41 pts/3 00:00:00 sqlplus as sysdbaoracle 10144 23896 0 10:42 pts/2 00:00:00 grep sqlplus

Usted observa que el proceso aún se está ejecutando. No ha finalizado. Para finalizar este proceso, y cualquier proceso que se resista a ser finalizado, debe enviar una nueva señal denominada SIGKILL. La señal por defecto es SIGTERM.

# kill -SIGKILL 9790# ps -aef|grep sqlplus|grep oracleoracle 10092 23916 0 10:42 pts/3 00:00:00 sqlplus as sysdbaoracle 10198 23896 0 10:43 pts/2 00:00:00 grep sqlplus

Tenga en cuenta las opciones -SIGSTOP y -SIGKILL, que envían una señal específica (detener y finalizar, respectivamente) al proceso. Del mismo modo hay otras señales que puede utilizar. Para obtener un listado de todas las señales disponibles, utilice la opción -l (la letra “L”, no el número “1”):

# 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) SIGUSR213) SIGPIPE 14) SIGALRM 15) SIGTERM 17) SIGCHLD18) SIGCONT 19) SIGSTOP 20) SIGTSTP 21) SIGTTIN22) SIGTTOU 23) SIGURG 24) SIGXCPU 25) SIGXFSZ26) SIGVTALRM 27) SIGPROF 28) SIGWINCH 29) SIGIO30) SIGPWR 31) SIGSYS 34) SIGRTMIN 35) SIGRTMIN+136) SIGRTMIN+2 37) SIGRTMIN+3 38) SIGRTMIN+4 39) SIGRTMIN+540) SIGRTMIN+6 41) SIGRTMIN+7 42) SIGRTMIN+8 43) SIGRTMIN+944) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12 47) SIGRTMIN+1348) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14 51) SIGRTMAX-1352) SIGRTMAX-12 53) SIGRTMAX-11 54) SIGRTMAX-10 55) SIGRTMAX-956) SIGRTMAX-8 57) SIGRTMAX-7 58) SIGRTMAX-6 59) SIGRTMAX-560) SIGRTMAX-4 61) SIGRTMAX-3 62) SIGRTMAX-2 63) SIGRTMAX-164) SIGRTMAX

También puede utilizar el numeral equivalente de la señal en lugar del verdadero nombre de la señal. Por ejemplo, en lugar de kill -SIGKILL 9790, usted puede utilizar kill -9 9790.

A propósito, este es un comando interesante. Recuerde que casi todos los comandos Linux generalmente son archivos ejecutables localizados en /bin, /sbin/, /user/bin y directorios similares. El PATH ejecutable determina en dónde pueden encontrarse estos archivos de comando. Algunos otros comandos son en realidad comandos “incorporados”, es decir, son parte del shell mismo. Un ejemplo de esto es el comando kill. Para demostrarlo, observe lo siguiente:

# kill -h -bash: kill: h: invalid signal specification

Observe el output que arroja el bash shell. El uso es incorrecto ya que el argumento -h no era el adecuado. Ahora utilice el siguiente:

# /bin/kill -husage: kill [ -s signal | -p ] [ -a ] pid ... kill -l [ signal ]

Esta versión del comando kill como ejecutable en el directorio /bin aceptó la opción -h

adecuadamente. Ahora usted ya conoce esta sutil diferencia entre los comandos shell incorporados y sus utilidades homónimas (namesake) en la forma de archivos ejecutables.

¿Por qué es importante conocer la diferencia? Es importante porque la funcionalidad varía de manera significativa entre estas dos formas. El comando kill incorporado tiene menos funcionalidad que su utilidad equivalente. Cuando usted emite el comando kill, en verdad está invocando el comando incorporado, no la utilidad. Para incorporar la otra funcionalidad, usted tiene que utilizar la utilidad /bin/kill.

La utilidad kill tiene muchas opciones y argumentos. El más conocido es el comando kill utilizado para finalizar los proceso con los nombres del proceso, en lugar de PIDs. Aquí vemos un ejemplo en el que usted puede finalizar todos los procesos con el nombre sqlplus:

# /bin/kill sqlplus[1] Terminated sqlplus[2] Terminated sqlplus[3] Terminated sqlplus[4] Terminated sqlplus[5] Terminated sqlplus[6] Terminated sqlplus[7]- Terminated sqlplus[8]+ Terminated sqlplus

Algunas veces usted quiere ver todos los IDs de los procesos que serán finalizados. La opción -p logra esto. Imprime los PIDs que deberían finalizarse, sin realmente finalizarlos. Sirve como confirmación previa a la acción:

# /bin/kill -p sqlplus67986802680368076808681268136817

Algunas veces usted quiere ver todos los IDs de los procesos que serán finalizados. La opción -p logra esto. Imprime los PIDs que deberían finalizarse, sin realmente finalizarlos. Sirve como confirmación previa a la acción:

# man -k builtin. [builtins] (1) - bash built-in commands, see bash(1): [builtins] (1) - bash built-in commands, see bash(1)[ [builtins] (1) - bash built-in commands, see bash(1)alias [builtins] (1) - bash built-in commands, see bash(1)bash [builtins] (1) - bash built-in commands, see bash(1)bg [builtins] (1) - bash built-in commands, see bash(1)… y así …

El output muestra los PIDs de los procesos que serían finalizados. Si usted reemite el comando sin la opción -p, se finalizarán todos esos procesos.

A esta altura usted quizás desee saber cuáles son los otros comandos “incorporados” en el shell, en lugar de las utilidades.

# /bin/kill perl rman perl dbca dbua java

Algunas entradas parecen conocidas – alias, bg, entre otras. Algunas se encuentran meramente

incorporadas, por ej., alias. No existe ningún archivo ejecutable llamado alias.


Finalizar un proceso ofrece muchos usos – mayormente se utiliza para finalizar procesos fantasmas, procesos que se encuentran en segundo plano y otros que han sido detenidos en respuesta a un cierre normal de los comandos. Por ejemplo, cuando la instancia de base de datos de Oracle no se está cerrado debido a un problema de memoria. Usted debe cerrarla finalizando uno de los procesos clave como pmon o smon. Esto no debería realizarse todo el tiempo, solo cuando no haya opción.

Si quizás desee finalizar todas las sesiones sqlplus o todos los trabajos rman utilizando el comando de utilidad kill. Los procesos Oracle Enterprise Manager se ejecutan como procesos perl; o procesos DBCA o DBUA, los cuales quizás quiera finalizar rápidamente:

# /bin/kill perl rman perl dbca dbua java

Existe también un uso más común de este comando. Cuando usted quiere finalizar una sesión de usuario en la Base de Datos de Oracle, generalmente realiza alguna de las siguientes acciones:

• Busca el SID y Serial# de la sesión • Finaliza la sesión utilizando el comando ALTER SYSTEM

Veamos qué sucede cuando desea finalizar la sesión del usuario SH.

SQL> select sid, serial#, status 2 from v$session 3* where username = 'SH';

SID SERIAL# STATUS---------- ---------- -------- 116 5784 INACTIVE SQL> alter system kill session '116,5784' 2 / System altered. La sesión ha finalizado; no obstante cuando usted controla en estado de la sesión:

SID SERIAL# STATUS---------- ---------- -------- 116 5784 KILLED

Se muestra como KILLED (finalizada), pero no se ha eliminado por completo. Eso sucede porque Oracle espera hasta que el usuario SH inicie su sesión e intente hacer algo, en ese momento recibe el mensaje “ORA-00028: su sesión ha sido finalizada”. Luego de ese momento la sesión desaparece de V$SESSION.

Una manera más rápida de finalizar una sesión es eliminar el correspondiente proceso del servidor en el nivel de Linux. Para hacerlo, primero busque el PID del proceso del servidor:

SQL> select spid 2 from v$process 3 where addr = 4 ( 5 select paddr 6 from v$session 7 where username = 'SH' 8 );SPID------------------------

30986

El SPID es el ID de Proceso del proceso del servidor. Ahora puede finalizar este proceso:

# kill -9 30986

Ahora si verifica la visión V$SESSION, ésta desaparecerá inmediatamente. El usuario no recibirá el mensaje instantáneamente; pero si intenta realizar una consulta a la base de datos, el obtendrá el siguiente mensaje:

ERROR at line 1:ORA-03135: connection lost contactProcess ID: 30986Session ID: 125 Serial number: 34528

Este en método rápido para finalizar una sesión, no obstante hay ciertos inconvenientes. La base de datos de Oracle debe realizar una limpieza de sesión –deshacer cambios (rollback), etc. Y esto debería realizarse solo cuando las sesiones se encuentran inactivas. Caso contrario, usted puede utilizar una de las dos otras maneras de finalizar una sesión inmediatamente:

alter system disconnect session '125,35447' immediate;alter system disconnect session '125,35447' post_transaction;

killallA diferencia de la naturaleza dual del comando kill, killall es meramente una utilidad, es decir, es un programa ejecutable en el directorio /usr/bin. El comando es similar a kill en funcionalidad pero en vez de finalizar un proceso sobre la base de su PID, éste acepta el nombre del proceso como argumento. Por ejemplo, para finalizar todos los procesos sqlplus, emita:

# killall sqlplus

Esto finaliza todos los procesos denominados sqlplus (los cuales usted tiene permiso de finalizar, por supuesto). A diferencia del comando kill incorporado, usted no necesita conocer el ID de Proceso de los procesos a finalizar.

Si el comando no finaliza el proceso o el proceso no responde a una señal TERM, usted puede enviar una señal SIGKILL explícita como pudo ver en el comando kill utilizando la opción -s.

# killall -s SIGKILL sqlplus

Como en el comando kill, usted puede utilizar la opción -9 en lugar de -s SIGKILL. Para obtener un listado de todas las señales disponibles, usted puede utilizar la opción -l.

# killall -lHUP INT QUIT ILL TRAP ABRT IOT BUS FPE KILL USR1 SEGV USR2 PIPE ALRM TERMSTKFLT CHLD CONT STOP TSTP TTIN TTOU URG XCPU XFSZ VTALRM PROF WINCH IO PWR SYSUNUSED

Para obtener el output completo del comando killall, utilice la opción -v:

# killall -v sqlplusKilled sqlplus(26448) with signal 15Killed sqlplus(26452) with signal 15Killed sqlplus(26456) with signal 15Killed sqlplus(26457) with signal 15… and so on …

Algunas veces usted quizás quiera examinar el proceso antes de finalizarlo. La opción -i le permite

ejecutarlo interactivamente. Esta opción solicita su input antes de finalizarlo:

# killall -i sqlplusKill sqlplus(2537) ? (y/n) nKill sqlplus(2555) ? (y/n) nKill sqlplus(2555) ? (y/n) yKilled sqlplus(2555) with signal 15

¿Qué sucede cuando usted aprueba un nombre de proceso equivocado?

# killall wrong_processwrong_process: no process killed

No existe ningún proceso de ejecución denominado wrong_process entonces no se ha finalizado nada y el output lo ha mostrado claramente. Para eliminar este reclamo “no process killed”, utilice la opción -q. Esa opción es muy útil en shell scripts en donde usted no puede analizar el output. En cambio, si usted desea capturar el código de retorno del comando:

# killall -q wrong_process# echo $?1

El código de retorno (que se muestra en la variable shell $?) es “1”, en vez de “0”, lo cual indica una falla. Usted puede controlar el código de retorno para examinar si el proceso killall resultó exitoso, es decir, si el código de retorno es “0”.

Algo interesante en torno a este comando es que no se finaliza por si mismo. Por supuesto hace finalizar otros comandos killall en otro sitio pero no en si mismo.


Al igual que el comando kill, el comando killall también es utilizado para finalizar procesos. La mayor ventaja de killall es la capacidad de desplegar el processid y la naturaleza interactiva que posee. Supongamos que usted desea finalizar todos los procesos perl, java, sqlplus, rman y dbca pero no de manera interactiva; usted puede emitir:

# killall -i -p perl sqlplus java rman dbcaKill sqlplus(pgid 7053) ? (y/n) nKill perl(pgid 31233) ? (y/n) n... and so on ...

Esto le permite ver el PID antes de finalizarlos, lo cual puede ser muy útil.

ConclusionEn este documento usted conoció los siguientes comandos (mostrados alfabéticamente)

dig Una nueva versión de nslookup

ifconfig Para desplegar información en las interfaces de red

kill Para finalizar un proceso específico

killall Para finalizar un proceso específico, un grupo de procesos y los nombres que coinciden con un patrón

mesg Para activar o desactivar la capacidad de los demás para desplegar algo en la terminal de uno.

netstat Para desplegar estadísticas y otras métricas sobre el uso de la interfaz de red

nslookup Para buscar el nombre de host de su dirección de IP o buscar la dirección de IP para su nombre de host en DNS

talk Para establecer un sistema de Mensajería Instantánea entre dos usuarios para lograr una conversación en tiempo real

uptime Para saber por cuánto tiempo ha estado funcionando el sistema y conocer su carga promedio en 1, 5 y 15 minutos

w Es una combinación de uptime y who

wall Para desplegar texto en las terminales de todos los usuarios que han iniciado sesión

who Para desplegar a todos los usuarios que han iniciado sesión en el sistema y para saber lo que están haciendo

write Para desplegar instantáneamente algo en la sesión de la terminal de un usuario específico

Como he mencionado anteriormente, no es mi intención presentarles cada comando disponible en los sistemas Linux. Usted debe conocer solo algunos de ellos para administrar un sistema de manera efectiva y esta serie le muestra los más importantes. Practíquelos en su entorno para comprenderlos mejor – con sus parámetros y opciones. En el próximo documento, el último de ellos, usted aprenderá a administrar un entorno Linux – en una máquina común, en una máquina virtual, y en la nube.

Documents

59298441 Comandos Linux Oracle