jueves, 30 de marzo de 2017

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



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

En la Parte 1 de la serie, usted aprendió algunos comandos útiles no tan conocidos y algunos de los comandos comúnmente utilizados pero con parámetros no tan conocidos para hacer su trabajo de manera más eficiente. Para continuar con la serie, ahora aprenderá algunos comandos Linux más avanzados útiles para los usuarios Oracle, ya sean desarrolladores o DBAs.
Alias y unalias
Supongamos que quiere verificar el grupo de variables del entorno ORACLE_SID de su shell. Deberá tipear:
echo $ORACLE_HOME

Como DBA o desarrollador, utiliza frecuentemente este comando y pronto se cansa de tipear los 16 caracteres. ¿Hay una manera más simple?
Sí: el comando alias. Con este enfoque, puede crear un breve alias, como "os", para representar todo el comando:
alias os='echo $ORACLE_HOME'

Ahora cuando quiera verificar ORACLE_SID, simplemente escriba "os" (sin comillas) y Linux ejecuta el comando con el alias.
No obstante, si se desconecta y se vuelve a conectar, el alias es eliminado y debe ingresar el comando alias nuevamente. Para eliminar este paso, todo lo que debe hacer es colocar el comando en su archivo de perfil shell. Para bash, el archivo es .bash_profile (note el punto antes del nombre de archivo, es parte del nombre de archivo) en su directorio de inicio. Para los shells bourne y korn, es .profile, y para c-shell, .chsrc.
Usted puede crear un alias para cualquier nombre. Por ejemplo, yo siempre creo un alias para el comando rm como rm -i, que hace que el comando rm sea interactivo.
alias rm=’rm -i’

Cuando emito un comando rm, Linux solicita mi confirmación, y a menos que agregue "y", no elimina el archivo—así quedo protegido ante la posibilidad de eliminar accidentalmente un archivo importante. Utilizo lo mismo para mv (para cambiar el archivo a otro nombre), lo cual evita la sobrescritura accidental de archivos existentes, y cp (para copiar el archivo).
A continuación, presentamos una lista de algunos alias muy útiles que quiero definir:
alias bdump='cd $ORACLE_BASE/admin/$ORACLE_SID/bdump'
alias l='ls -d .* --color=tty'
alias ll='ls -l --color=tty'
alias mv='mv -i'
alias oh='cd $ORACLE_HOME'
alias os='echo $ORACLE_SID'
alias rm='rm -i'
alias tns='cd $ORACLE_HOME/network/admin'

Para ver qué alias han sido definidos en su shell, use alias sin ningún parámetro.
Sin embargo, hay un pequeño problema. He definido un alias, rm, que ejecuta rm -i. Este comando solicitará mi confirmación cada vez que intente eliminar un archivo. ¿Pero qué sucede si quiero eliminar muchos archivos y estoy seguro de que pueden eliminarse sin mi confirmación?
La solución es simple: Para suprimir el alias y utilizar solo el comando, necesitaré ingresar dos comillas simples:
$ ''rm *

Fíjese que se trata de dos comillas simples (') antes del comando rm, no dos comillas dobles. Esto suprimirá el alias rm. Otro enfoque es utilizar una barra inversa (\):
$ \rm *

Para eliminar un alias previamente definido, simplemente utilice el comando unalias:
$ unalias rm


ls


El comando ls es frecuentemente utilizado pero pocas veces es utilizado en su totalidad. Sin ninguna opción, ls despliega meramente todos los archivos y directorios en formato tabular.
$ ls
admin            has                  mesg         precomp
apex             hs                   mgw          racg
assistants       install              network      rdbms
                         
... output snipped ...
                      
Para mostrarlos en una lista, use la opción -1 (el número 1, no la letra "l").
$ ls -1
admin
apex
assistants
                         
... output snipped ...
                      
Esta opción es útil en shell scripts donde los nombres de archivo necesitan incorporarse en otro programa o comando para la manipulación.
Seguramente, usted utilizó -l (la letra "l", no el número "1") que despliega todos los atributos de los archivos y directorios. Veámoslo una vez más:
$ ls -l 
total 272
drwxr-xr-x    3 oracle   oinstall     4096 Sep  3 03:27 admin
drwxr-x---    7 oracle   oinstall     4096 Sep  3 02:32 apex
drwxr-x---    7 oracle   oinstall     4096 Sep  3 02:29 assistants

La primera columna muestra el tipo de archivo y los permisos sobre él: "d" significa directorio, "-" significa archivo regular, "c" significa un dispositivo de caracteres, "b" significa un dispositivo de bloques, "p" significa named pipe, y "l" (letra minúscula L, no I) significa enlace simbólico.
Una opción muy útil es --color, que muestra los archivos en muchos colores diferentes de acuerdo con el tipo de archivo. Aquí hay un ejemplo:

Fíjese que los archivos 1 y 2 son archivos comunes. link1 es un enlace simbólico, que se muestra en rojo; dir1 es un directorio y se muestra en amarillo; y pipe1 es un named pipe, y se muestra en diferentes colores para una identificación más fácil.
En algunos distros, el comando ls viene preinstalado con un alias (descripto en la sección anterior) como ls --color; de manera que usted pueda ver los archivos en color cuando tipea "ls". Este enfoque puede no ser aconsejable, especialmente si tiene un output como ese arriba. Puede cambiar los colores, pero una forma más rápida puede ser simplemente suspender el alias:
$ alias ls="''ls"  

Otra opción útil es la opción -F, que añade un símbolo después de cada archivo para mostrar el tipo de archivo - una "/" después de los directorios, "@" después de enlaces simbólicos, y "|" después de named pipes.
$ ls -F
dir1/  file1  file2  link1@  pipe1|

Si tiene un subdirectorio en un directorio y quiere hacer solo una lista de ese directorio, ls -l le mostrará los contenidos del subdirectorio también. Por ejemplo, supongamos que la estructura de directorio es la siguiente:
/dir1
+-->/subdir1
+--> subfile1
+--> subfile2

El directorio dir1 tiene un subdirectorio subdir1 y dos archivos: subfile1 y subfile2. Si solo desea ver los atributos del directorio dir1, emite:
$ ls -l dir1
total 4
drwxr-xr-x    2 oracle   oinstall     4096 Oct 14 16:52 subdir1
-rw-r--r--    1 oracle   oinstall        0 Oct 14 16:48 subfile1
-rw-r--r--    1 oracle   oinstall        0 Oct 14 16:48 subfile2

Fíjese que el directorio dir1 no está en la lista del output. En cambio, se muestran los contenidos del directorio. Este es un comportamiento esperado cuando se procesan directorios. Para mostrar únicamente el directorio dir1, deberá utilizar el comando -d.
$ ls -dl dir1
drwxr-xr-x    3 oracle   oinstall     4096 Oct 14 16:52 dir1

Vea el output del siguiente output ls -l:
-rwxr-x--x    1 oracle   oinstall 10457761 Apr  6  2006 rmanO
-rwxr-x--x    1 oracle   oinstall 10457761 Sep 23 23:48 rman
-rwsr-s--x    1 oracle   oinstall 93300507 Apr  6  2006 oracleO
-rwx------    1 oracle   oinstall 93300507 Sep 23 23:49 oracle

Notará que los tamaños de los archivos se muestran en bytes. Esto puede ser fácil en archivos pequeños, pero cuando el tamaño de los archivos es grande, puede no ser tan fácil leer un número largo. La opción "-h" es práctica aquí, para mostrar el tamaño de manera legible para personas.
$ ls -lh

-rwxr-x--x    1 oracle   oinstall      10M Apr  6  2006 rmanO
-rwxr-x--x    1 oracle   oinstall      10M Sep 23 23:48 rman
-rwsr-s--x    1 oracle   oinstall      89M Apr  6  2006 oracleO
-rwx------    1 oracle   oinstall      89M Sep 23 23:49 oracle

Fíjese cómo se muestra el tamaño en M (para megabytes), K (para kilobytes), etc.
$ ls -lr

El parámetro -r muestra el output en orden inverso. En este comando, los archivos se mostrarán en orden alfabético inverso.
$ ls -lR

El operador -R hace que el comando ls se ejecute repetitivamente—es decir, explorar los subdirectorios y mostrar esos archivos también.
¿Qué sucede si quiere mostrar los archivos del más grande al más chico? Esto puede realizarse con el parámetro -S.
$ ls -lS

total 308
-rw-r-----    1 oracle   oinstall    52903 Oct 11 18:31 sqlnet.log
-rwxr-xr-x    1 oracle   oinstall     9530 Apr  6  2006 root.sh
drwxr-xr-x    2 oracle   oinstall     8192 Oct 11 18:14 bin
drwxr-x---    3 oracle   oinstall     8192 Sep 23 23:49 lib


xargs


La mayoría de los comandos Linux tienen el fin de obtener un output: una lista de archivos, una lista de sucesiones, etc. ¿Pero qué sucede si quiere utilizar algún otro comando con el output del anterior como parámetro? Por ejemplo, el comando file muestra el tipo de archivo (ejecutable, texto ascii, etc.); puede manipular el output para que muestre solo los nombres de archivo y ahora quiere pasar estos nombres al comando ls -l para ver la fecha de registro. El comando xargs hace exactamente eso. Permite ejecutar algunos otros comandos en el output. Recuerde esta sintaxis de la Parte 1:
file -Lz * | grep ASCII | cut -d":" -f1 | xargs ls -ltr

Ahora, queremos utilizar el comando ls -l y pasar la lista de arriba como parámetros, uno a la vez. El comando xargs le permitió hacer eso. La última parte, xargs ls -ltr, toma el output y ejecuta el comando ls -ltr sobre ellos, como si ejecutase:
alert_DBA102.log:        ASCII English text
alert_DBA102.log.Z:      ASCII text (compress'd data 16 bits)
dba102_asmb_12307.trc.Z: ASCII English text (compress'd data 16 bits)
dba102_asmb_20653.trc.Z: ASCII English text (compress'd data 16 bits)

xargs no es útil por sí mismo, pero es bastante bueno cuando se combina con otros comandos. Aquí se muestra otro ejemplo, donde queremos contaar la cantidad de líneas en esos archivos:
alert_DBA102.log
alert_DBA102.log.Z
dba102_asmb_12307.trc.Z
dba102_asmb_20653.trc.Z

Ahora, queremos utilizar el comando ls -l y pasar la lista de arriba como parámetros, uno a la vez. El comando xargs le permitió hacer eso. La última parte, xargs ls -ltr, toma el output y ejecuta el comando ls -ltr sobre ellos, como si ejecutase:
ls -ltr alert_DBA102.log
ls -ltr alert_DBA102.log.Z
ls -ltr dba102_asmb_12307.trc.Z
ls -ltr dba102_asmb_20653.trc.Z

xargs no es útil por sí mismo, pero es bastante bueno cuando se combina con otros comandos.
Aquí se muestra otro ejemplo, donde queremos contaar la cantidad de líneas en esos archivos:
$ file * | grep ASCII | cut -d":" -f1  | xargs wc -l
  47853 alert_DBA102.log
     19 dba102_cjq0_14493.trc
  29053 dba102_mmnl_14497.trc
    154 dba102_reco_14491.trc
     43 dba102_rvwr_14518.trc
  77122 total

(Nota: la tarea de arriba también puede lograrse con el siguiente comando:)
$ wc -l ‘file * | grep ASCII | cut -d":" -f1 | grep ASCII | cut -d":" -f1‘

La versión xargs está dada para ilustrar el concepto. Linux tiene varias maneras de lograr la misma tarea; use la que mejor se adapte a su situación.
Al utilizar este enfoque, usted puede rápidamente renombrar los archivos de un directorio.
$ ls | xargs -t -i mv {} {}.bak

La opción -i le comunica a xargs que reemplace {} con el nombre de cada elemento. La opción -t ordena a xargs que imprima el comando antes de ejecutarlo.
Otra operación es muy útil cuando quiere abrir los archivos para edición utilizando vi:
$ file * | grep ASCII | cut -d":" -f1 | xargs vi

Este comando abre los archivos uno por uno utilizando vi. Cuando quiere buscar muchos archivos y abrirlos para edición, esto resulta muy útil.
También tiene varias opciones. Tal vez la más útil es la opción -p, que hace que la operación sea interactiva:
$ file * | grep ASCII | cut -d":" -f1 | xargs -p vi
vi alert_DBA102.log dba102_cjq0_14493.trc dba102_mmnl_14497.trc
dba102_reco_14491.trc dba102_rvwr_14518.trc ?...
                      
Aquí xarg le pide confirmación antes de ejecutar cada comando. Si presiona "y", ejecuta el comando. Le resultará extremadamente útil cuando realice algunas operaciones potencialmente perjudiciales e irreversibles en el archivo—como eliminar o sobrescribirlo.
La opción -t utiliza un modo verboso; despliega el comando que está por ejecutar, la cual es una opción muy útil durante la depuración.
¿Qué sucede si el output pasara a xargs en blanco? Considere:
$ file * | grep SSSSSS | cut -d":" -f1 | xargs -t wc -l
wc -l 
            0
$

Aquí buscar "SSSSSS" no produce ninguna concordancia; entonces el input de xargs son todos espacios en blanco, como se muestra en la segunda línea (producida al utilizar la opción -t o verbosa). A pesar de que esto puede ser útil, en algunos casos usted puede querer detener xargs si no hay nada que procesar; si lo hay, puede utilizar la opción -r:
$ file * | grep SSSSSS | cut -d":" -f1 | xargs -t -r wc -l
$

El comando existe si no hay nada que ejecutar.
Supongamos que quiere eliminar los archivos utilizando el comando rm, que debería ser el argumento para el comando xargs. No obstante, rm puede aceptar una cantidad limitada de argumentos. ¿Qué sucede si su lista de argumentos excede ese límite? La opción -n para xargs limita la cantidad de argumentos en una sola línea de comando.
Aquí mostramos cómo puede limitar solo dos argumentos por línea de comando: Incluso si cinco líneas pasan a xargs ls -ltr, solo dos archivos pasan a ls -ltr por vez.
$ file * | grep ASCII | cut -d":" -f1 | xargs -t -n2 ls -ltr  
ls -ltr alert_DBA102.log dba102_cjq0_14493.trc 
-rw-r-----    1 oracle   dba           738 Aug 10 19:18 dba102_cjq0_14493.trc
-rw-r--r--    1 oracle   dba       2410225 Aug 13 05:31 alert_DBA102.log
ls -ltr dba102_mmnl_14497.trc dba102_reco_14491.trc 
-rw-r-----    1 oracle   dba       5386163 Aug 10 17:55 dba102_mmnl_14497.trc
-rw-r-----    1 oracle   dba          6808 Aug 13 05:21 dba102_reco_14491.trc
ls -ltr dba102_rvwr_14518.trc 
-rw-r-----    1 oracle   dba          2087 Aug 10 04:30 dba102_rvwr_14518.trc

Utilizando este enfoque, usted puede rápidamente renombrar los archivos de un directorio.
$ ls | xargs -t -i mv {} {}.bak

La opción -i le comunica a xargs que reemplace {} con el nombre de cada elemento.

rename


Como sabe, el comando mv renombra los archivos. Por ejemplo,
$ mv oldname newname
oldnamenewnamerename
rename .log .log.‘date +%F-%H:%M:%S‘ *

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

find


Ente los usuarios Oracle, el más conocido es el comando find. Hasta ahora, sabe cómo utilizar find para buscar archivos en un directorio determinado. Aquí mostramos un ejemplo que comienza con la palabra "file" en el directorio actual:
$ find . -name "file*"
./file2
./file1
./file3
./file4

No obstante, ¿qué sucede si quiere buscar nombres como FILE1, FILE2, etc.? -name "file*" no tendrá concordancia. Para una búsqueda con distinción de mayúsculas y minúsculas, use la opción -iname:
$ find . -iname "file*"
./file2
./file1
./file3
./file4
./FILE1
./FILE2

Puede restringir su búsqueda a un tipo específico de archivos. Por ejemplo, el comando de arriba obtendrá archivos de todo tipo: archivos comunes, directorios, enlaces simbólicos, etc. Para buscar solo archivos comunes, puede utilizar el parámetro -type f.
$ find . -name "orapw*" -type f 
./orapw+ASM
./orapwDBA102
./orapwRMANTEST
./orapwRMANDUP
./orapwTESTAUX

-type puede tomar los modificadores f (para archivos comunes), l (para enlaces simbólicos), d (directorios), b (dispositivos de bloque), p (named pipes), c (dispositivos de caracteres), s (sockets).
Un pequeño cambio en el comando de arriba es combinarlo con el comando file que conoció en la Parte 1. El comando file le dice qué tipo de archivo es. Puede transmitirlo como post procesador para el output desde el comando find. El parámetro -exec ejecuta el comando que sigue el parámetro. En este caso, el comando a ejecutar después de find es file:
$ find . -name "*oraenv*" -type f -exec file {} \;
./coraenv: Bourne shell script text executable
./oraenv: Bourne shell script text executable

Esto es útil cuando quiere descubrir si el archivo de texto ASCII podría ser algún tipo de shell script.
Si sustituye -exec con -ok, el comando es ejecutado pero solicita confirmación primero. Aquí hay un ejemplo:
$ find . -name "sqlplus*" -ok {} \;      
< {} ... ./sqlplus > ? y
 
SQL*Plus: Release 9.2.0.5.0 - Production on Sun Aug 6 11:28:15 2006
 
Copyright (c) 1982, 2002, Oracle Corporation.  All rights reserved.
 
Enter user-name: / as sysdba
 
Connected to:
Oracle9i Enterprise Edition Release 9.2.0.5.0 - 64bit Production
With the Partitioning,Real Application Clusters,OLAP 
and Oracle Data Mining options
JServer Release 9.2.0.5.0 - Production
 
SQL> exit
Disconnected from Oracle9i Enterprise Edition Release 9.2.0.5.0-64bit Production
With the Partitioning,Real Application Clusters,OLAP 
and Oracle Data Mining options
JServer Release 9.2.0.5.0 - Production
< È* ... ./sqlplusO > ? n
$

Aquí, hemos pedido al shell que busque todos los programas que comienzan con "sqlplus", y que los ejecute. Fíjese que no hay nada entre -ok y {}, por lo tanto solo ejecutará los archivos que encuentre. Encuentra dos archivos—sqlplus y sqlplusO—y en ambos casos pregunta si usted desea ejecutarlos. Respondemos "y" para el prompt de "sqlplus" y lo ejecuta. Después de salir, solicita el segundo archivo que encontró (sqlplusO) y solicita confirmación una y otra vez, a lo cual respondimos "n"—entonces, no se ejecutó.

Consejo para Usuarios Oracle


Oracle produce varios archivos extraños: archivos de localización, archivos testigo, archivos dump, etc. A menos que se limpien periódicamente, pueden llenar el sistema de archivos e interrumpir la base de datos.
Para garantizar que eso no suceda, simplemente busque los archivos con extensión "trc" y elimínelos si tienen más de tres días de antigüedad. Un comando simple es la solución:
find . -name "*.trc" -ctime +3 -exec rm {} \;

Para eliminarlos antes del límite de tres días, use la opción -f.
           
find . -name "*.trc" -ctime +3 -exec rm -f {} \;

Si simplemente desea enumerar los archivos:
find . -name "*.trc" -ctime +3 -exec ls -l {} \;


m4


Este comando toma un archivo input y sustituye las cadenas dentro de él con los parámetros transmitidos, lo cual es similar a sustituirlas por variables. Por ejemplo, vea un archivo input:
$ cat temp
The COLOR fox jumped over the TYPE fence.

Si quiere sustituir las cadenas "COLOR" por "brown" y "TYPE" por "broken", puede utilizar:
$ m4 -DCOLOR=brown -DTYPE=broken temp
The brown fox jumped over the broken fence.
Else, if you want to substitute "white" and "high" for the same:

$ m4 -DCOLOR=white -DTYPE=high temp  
The white fox jumped over the high fence.


whence y which


Estos comandos son utilizados para saber dónde se almacenan los ejecutables mencionados en el PROCESO del usuario. Cuando el ejecutable es encontrado en el proceso, se comportan de manera bastante similar y muestran el proceso:
                         
$ which sqlplus  
/u02/app/oracle/products/10.2.0.1/db1/bin/sqlplus
$ whence sqlplus 
/u02/app/oracle/products/10.2.0.1/db1/bin/sqlplus

                      
El output es idéntico. Sin embargo, si el ejecutable no es encontrado en el proceso, el comportamiento es diferente. El comando which produce un mensaje explícito:
$ which sqlplus1
/usr/bin/which: no sqlplus1 in (/u02/app/oracle/products/10.2.0.1/db1/bin:/usr
/kerberos/bin:/usr/local/bin:/bin:/usr/bin:/usr/X11R6/bin)
                      
whereas El comando whence no produce mensaje:
$ whence sqlplus1]

y vuelve a shell prompt. Esto es útil en casos donde el ejecutable no es encontrado en el proceso (en lugar de mostrar el mensaje):
  
$ whence invalid_command
$ which invalid_command
which: no invalid_command in (/usr/kerberos/sbin:/usr/kerberos/bin:/bin:/sbin: 
/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:
/usr/bin/X11:/usr/X11R6/bin:/root/bin)     
                      
Cuando whence no encuentra un ejecutable en el proceso, vuelve sin ningún mensaje pero el código de retorno no es cero. Esto puede utilizarse en shell scripts; por ejemplo:
RC=‘whence myexec‘
If [ $RC -ne "0" ]; then
   echo "myexec is not in the $PATH"
fi

Una opción muy útil es la opción -i, que muestra el alias y el ejecutable, si está presente. Por ejemplo, usted pudo ver el uso del alias al comienzo de este artículo. El comando rm es en realidad un alias en mi shell, y también en cualquier lugar donde haya un comando rm en el sistema.
$ which ls /bin/ls  $ which -i ls alias ls='ls --color=tty'         /bin/ls 
El comportamiento por defecto es mostrar la primera ocurrencia del ejecutable en el proceso. Si el ejecutable existe en diferentes directorios del proceso, las ocurrencias subsiguientes son ignoradas. Puede ver todas las ocurrencias del ejecutable mediante la opción -a.
$ which java   
/usr/bin/java

$ which -a java
/usr/bin/java
/home/oracle/oracle/product/11.1/db_1/jdk/jre/bin/java


top


El comando top es probablemente el más útil para un Oracle DBA que administra una base de datos sobre Linux. Digamos que el sistema es lento y quiere saber quién está saturando la CPU y/o memoria. Para mostrar los procesos clave, utiliza el comando top.
Fíjese que a diferencia de otros comandos, top no produce un output y permanece inactivo. Actualiza la pantalla para mostrar nueva información. Por lo tanto, si simplemente activa top y deja la pantalla activa, siempre contará con la información más actual. Para cancelar e ir hacia shell, puede presionar Control-C.
$ top

18:46:13  up 11 days, 21:50,  5 users,  load average: 0.11, 0.19, 0.18 
151 processes: 147 sleeping, 4 running, 0 zombie, 0 stopped 
CPU states:  cpu    user    nice  system    irq  softirq  iowait    idle 
           total   12.5%    0.0%    6.7%   0.0%     0.0%    5.3%   75.2% 
Mem:  1026912k av,  999548k used,   27364k free,       0k shrd,  116104k buff 
                    758312k actv,  145904k in_d,   16192k in_c 
Swap: 2041192k av,  122224k used, 1918968k free                  590140k cached 
 
  PID USER     PRI  NI  SIZE  RSS SHARE STAT %CPU %MEM   TIME CPU COMMAND 
  451 oracle    15   0  6044 4928  4216 S     0.1  0.4   0:20   0 tnslsnr 
 8991 oracle    15   0  1248 1248   896 R     0.1  0.1   0:00   0 top 
    1 root      19   0   440  400   372 S     0.0  0.0   0:04   0 init 
    2 root      15   0     0    0     0 SW    0.0  0.0   0:00   0 keventd 
    3 root      15   0     0    0     0 SW    0.0  0.0   0:00   0 kapmd 
    4 root      34  19     0    0     0 SWN   0.0  0.0   0:00   0 ksoftirqd/0 
    7 root      15   0     0    0     0 SW    0.0  0.0   0:01   0 bdflush 
    5 root      15   0     0    0     0 SW    0.0  0.0   0:33   0 kswapd 
    6 root      15   0     0    0     0 SW    0.0  0.0   0:14   0 kscand 
    8 root      15   0     0    0     0 SW    0.0  0.0   0:00   0 kupdated 
    9 root      25   0     0    0     0 SW    0.0  0.0   0:00   0 mdrecoveryd
                         
... output snipped ...
                      
Examinemos los diferentes tipos de información producidos. La primera línea:
18:46:13  up 11 days, 21:50,  5 users,  load average: 0.11, 0.19, 0.18

muestra la hora actual (18:46:13), que el sistema ha estado activo durante 11 días; que el sistema ha trabajado durante 21 horas 50 segundos. Se muestra el promedio de carga del sistema (0.11, 0.19, 0.18) para los últimos 1, 5 y 15 minutos respectivamente. (A propósito, usted también puede obtener esta información ejecutando el uptime command.)
Si el promedio de carga no es necesario, presione la letra "l" (L minúscula); lo desactivará. Para volver a activarlo presione l nuevamente. La segunda línea:
151 processes: 147 sleeping, 4 running, 0 zombie, 0 stopped

muestra la cantidad de procesos, en ejecución, inactivos, etc. La tercera y cuarta línea:
CPU states:  cpu    user    nice  system    irq  softirq  iowait    idle 
           total   12.5%    0.0%    6.7%   0.0%     0.0%    5.3%   75.2%

muestran los detalles del uso de CPU. La línea de arriba muestra que los procesos de los usuarios consumen un 12,5% y el sistema consume un 6,7%. Los procesos del usuario incluyen los procesos Oracle. Presione "t" para activar y desactivar estas tres líneas. Si hay más de una CPU, usted verá una línea por CPU.
Las próximas dos líneas:
Mem:  1026912k av, 1000688k used,  26224k free,    0k shrd,  113624k buff 
                    758668k actv,  146872k in_d,  14460k in_c
Swap: 2041192k av, 122476k used,   1918716k free             591776k cached

muestran la memoria disponible y utilizada. La memoria total es "1026912k av", aproximadamente 1GB, de la cual solo 26224k o 26MB está libre. El espacio de intercambio es de 2GB; pero casi no es utilizado. Para activarlo y desactivarlo, presione "m".
El resto muestra los procesos en un formato tabular. A continuación, se explican las columnas:
ColumnaDescripción
PIDEl ID del proceso
USEREl usuario que ejecuta el proceso
PRILa prioridad del proceso
NIEl valor nice: Cuanto más alto es el valor, más baja es la prioridad de la tarea
SIZEMemoria utilizada por este proceso (código+datos+stack)
RSSMemoria física utilizada por este proceso
SHAREMemoria compartida utilizada por este proceso
STATEl 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)
%CPUPorcentaje de CPU utilizado por este proceso
%MEMPorcentaje de memoria utilizado por este proceso
TIMETiempo total de CPU utilizado por este proceso
CPUSi este es un proceso de procesadores múltiples, esta columna indica el ID de la CPU sobre la cual se está ejecutando este proceso.
COMMANDComando utilizado por este proceso

Mientras se muestra top, puede presionar algunas teclas para formatear la representación visual como usted quiera. Presionar la tecla mayúscula M clasifica el output por uso de memoria. (Fíjese que utilizar la letra minúscula m activará o desactivará las líneas de resumen de memoria en la parte superior de la representación visual). Esto es muy útil cuando quiere descubrir quién consume la memoria. Vea un ejemplo de output:
PID USER     PRI  NI  SIZE  RSS SHARE STAT %CPU %MEM   TIME CPU COMMAND 
31903 oracle    15   0 75760  72M 72508 S     0.0  7.2   0:01   0 ora_smon_PRODB2 
31909 oracle    15   0 68944  66M 64572 S     0.0  6.6   0:03   0 ora_mmon_PRODB2 
31897 oracle    15   0 53788  49M 48652 S     0.0  4.9   0:00   0 ora_dbw0_PRODB2

Ahora que ya sabe cómo interpretar el output, veamos cómo utilizar los parámetros de línea de comando.
El más útil es -d, que indica la demora entre las actualizaciones de pantalla. Para actualizar cada segundo, use top -d 1.
La otra opción útil es -p. Si solo desea monitorear algunos procesos, no todos, puede especificar solo aquellos después de la opción -p. Para monitorear los procesos 13609, 13608 y 13554:
top -p 13609 -p 13608 -p 13554

Esto mostrará los resultados en el mismo formato que el comando top, pero solo esos procesos específicos.

Consejo para Usuarios Oracle


Es casi innecesario decir que top resulta muy útil para analizar el desempeño de los servidores de base de datos. Aquí mostramos un output top parcial.
20:51:14  up 11 days, 23:55,  4 users,  load average: 0.88, 0.39, 0.27 
113 processes: 110 sleeping, 2 running, 1 zombie, 0 stopped 
CPU states:  cpu    user    nice  system    irq  softirq  iowait    idle 
           total    1.0%    0.0%    5.6%   2.2%     0.0%   91.2%    0.0% 
Mem:  1026912k av, 1008832k used,   18080k free,       0k shrd,   30064k buff 
                    771512k actv,  141348k in_d,   13308k in_c 
Swap: 2041192k av,   66776k used, 1974416k free                  812652k cached 
 
  PID USER     PRI  NI  SIZE  RSS SHARE STAT %CPU %MEM   TIME CPU COMMAND 
16143 oracle    15   0 39280  32M 26608 D     4.0  3.2   0:02   0 oraclePRODB2...
    5 root      15   0     0    0     0 SW    1.6  0.0   0:33   0 kswapd
                           
... output snipped ...
                        
Analicemos el output cuidadosamente. Lo primero que debería notar es que la columna "inactiva" de la CPU indica; 0,0%—es decir, la CPU está completamente ocupada haciendo algo. La pregunta es, ¿haciendo qué? Preste atención a la columna "sistema", ligeramente a la izquierda; muestra 5,6%. Entonces el sistema no está haciendo mucho. Vaya más a la izquierda hasta la columna "usuario", que muestra 1,0%. Como los procesos de usuarios incluyen Oracle también, Oracle no consume los ciclos de CPU. Por lo tanto, ¿qué consume toda la CPU?
La respuesta está en la misma línea, justo a la derecha en la columna "iowait", que indica un 91,2%. Esto lo explica todo: la CPU está esperando IO el 91,2% del tiempo.
¿Entonces, por qué tanta espera por IO? La respuesta está en la pantalla. Fíjese en el PID del proceso con mayor consumo: 16143. Puede utilizar la siguiente consulta para determinar qué está haciendo el proceso:
select s.sid, s.username, s.program
from v$session s, v$process p
where spid = 16143
and p.addr = s.paddr
/

       SID USERNAME PROGRAM
------------------- -----------------------------
       159 SYS      rman@prolin2 (TNS V1-V3)    

El proceso rman está reduciendo los ciclos de CPU relacionados con la espera de IO. Esta información ayuda a determinar el próximo plan de acción.

skill y snice


En el debate anterior, aprendió cómo identificar un recurso de consumo de CPU. ¿Qué sucede si descubre que un proceso consume mucha CPU y memoria, pero no quiere cancelarlo? Considere este output top:
$ top -c -p 16514

23:00:44  up 12 days,  2:04,  4 users,  load average: 0.47, 0.35, 0.31 
1 processes: 1 sleeping, 0 running, 0 zombie, 0 stopped 
CPU states:  cpu    user    nice  system    irq  softirq  iowait    idle 
           total    0.0%    0.6%    8.7%   2.2%     0.0%   88.3%    0.0% 
Mem:  1026912k av, 1010476k used,   16436k free,       0k shrd,   52128k buff 
                    766724k actv,  143128k in_d,   14264k in_c 
Swap: 2041192k av,   83160k used, 1958032k free                  799432k cached 
 
  PID USER     PRI  NI  SIZE  RSS SHARE STAT %CPU %MEM   TIME CPU COMMAND 
16514 oracle    19   4 28796  26M 20252 D N   7.0  2.5   0:03   0 oraclePRODB2...

Ahora que confirmó que el proceso 16514 consume mucha memoria, puede "congelarlo"—pero no cancelarlo—usando el comando skill.
$ skill -STOP 1

Luego, vea el output top:
23:01:11  up 12 days,  2:05,  4 users,  load average: 1.20, 0.54, 0.38 
1 processes: 0 sleeping, 0 running, 0 zombie, 1 stopped 
CPU states:  cpu    user    nice  system    irq  softirq  iowait    idle 
           total    2.3%    0.0%    0.3%   0.0%     0.0%    2.3%   94.8% 
Mem:  1026912k av, 1008756k used,   18156k free,       0k shrd,    3976k buff 
                    770024k actv,  143496k in_d,   12876k in_c 
Swap: 2041192k av,   83152k used, 1958040k free                  851200k cached 
 
  PID USER     PRI  NI  SIZE  RSS SHARE STAT %CPU %MEM   TIME CPU COMMAND 
16514 oracle    19   4 28796  26M 20252 T N   0.0  2.5   0:04   0 oraclePRODB2...

La CPU ahora está un 94% inactiva, de 0%. El proceso queda efectivamente congelado. Después de algún tiempo, puede querer reanudar el proceso del coma:
$ skill -CONT 16514

Este enfoque es muy útil para congelar temporalmente los procesos a fin de hacer lugar para finalizar los procesos más importantes.
El comando es muy versátil. Si desea detener todos los procesos de usuario "oracle", hay únicamente un solo comando que lo hace todo:
$ skill -STOP oracle

Puede utilizar un usuario, PID, un comando o terminal id como argumento. Lo que se muestra a continuación detiene todos los comandos rman.
$ skill -STOP rman

Como puede ver, skill decide ese argumento que ingresó—un ID para el proceso, un id de usuario o un comando—y actúa en consecuencia. Esto puede causar problemas en algunos casos, donde puede tener un usuario y un comando con el mismo nombre. El mejor ejemplo es el proceso "oracle", que en general es ejecutado por el usuario "oracle". Por lo tanto, cuando quiere detener el proceso denominado "oracle" y realiza:
$ skill -STOP oracle

todos los procesos del usuario "oracle" se detienen, incluso la sesión que puede estar ejecutando en ese momento. Para ser completamente ambiguo, puede opcionalmente ofrecer un nuevo parámetro para especificar el tipo de parámetro. Para detener un comando llamado oracle, puede:
$ skill -STOP -c oracle

El comando snice es similar. En lugar de detener un proceso, hace que su prioridad sea más baja. Primero, vea el output:
  PID USER     PRI  NI  SIZE  RSS SHARE STAT %CPU %MEM   TIME CPU COMMAND 
    3 root      15   0     0    0     0 RW    0.0  0.0   0:00   0 kapmd 
13680 oracle    15   0 11336  10M  8820 T     0.0  1.0   0:00   0 oracle 
13683 oracle    15   0  9972 9608  7788 T     0.0  0.9   0:00   0 oracle 
13686 oracle    15   0  9860 9496  7676 T     0.0  0.9   0:00   0 oracle 
13689 oracle    15   0 10004 9640  7820 T     0.0  0.9   0:00   0 oracle 
13695 oracle    15   0  9984 9620  7800 T     0.0  0.9   0:00   0 oracle 
13698 oracle    15   0 10064 9700  7884 T     0.0  0.9   0:00   0 oracle 
13701 oracle    15   0 22204  21M 16940 T     0.0  2.1   0:00   0 oracle

Ahora, reduzca cuatro puntos la prioridad de los procesos de "oracle". Fíjese que cuanto mayor es el número, más baja es la prioridad.
$ snice +4 -u oracle

  PID USER     PRI  NI  SIZE  RSS SHARE STAT %CPU %MEM   TIME CPU COMMAND 
16894 oracle    20   4 38904  32M 26248 D N   5.5  3.2   0:01   0 oracle

Note cómo la columna NI (para valores nice) ahora es 4 y la prioridad está ahora fijada en 20, en lugar de 15. Esto es bastante útil para reducir prioridades.

Cómo puedo borrar lo que hay en caché

sudo su
sync && echo 3 > /proc/sys/vm/drop_caches
exit

Lectura Adicional

viernes, 24 de marzo de 2017

TAREAS AUTOMATICAS ORACLE

SQL> 
SELECT JOB_NAME, SCHEDULE_NAME, SCHEDULE_TYPE, ENABLED
FROM DBA_SCHEDULER_JOBS
WHERE PROGRAM_NAME = 'GATHER_STATS_PROG';

JOB_NAME         SCHEDULE_NAME            SCHEDULE_TYPE  ENABLED
---------------- ------------------------ -------------- -------
GATHER_STATS_JOB MAINTENANCE_WINDOW_GROUP WINDOW_GROUP   TRUE


DBA_AUTOTASK_TASK

select * from DBA_AUTOTASK_TASK

PACKAGE DBMS_AUTO_TASK_ADMIN