Saltar al contenido
Interpretar errores

Principiante13 min de lectura

Me tronó en ejecución: cómo leer un abend

Un abend es el sistema deteniendo tu programa a media ejecución. Aquí aprendes a distinguirlo de otros finales malos, dónde mirar en la salida del job, cómo se lee el código y cómo llegar del offset a la línea del fuente que tronó.

Al terminar sabrás

  • Qué es un abend y en qué se distingue de un return code alto, un SQLCODE negativo o un file status distinto de 00.
  • Dónde mirar en la salida del job y en qué orden: mensajes del sistema, SYSOUT del step y CEEDUMP.
  • Cómo se lee el código: abend de sistema contra abend de usuario, y para qué sirve el reason code.
  • Cómo ir del offset del mensaje a la línea del fuente con el traceback o con el listado de OFFSET.

Antes de empezar

Esta guía da por hecho que ya sabes leer un listado de compilación y buscar una línea en él. Si no, empieza por Cómo leer un listado de compilación y regresa. Seguimos con el mismo programa inventado, CALCNOM1, el que acumula la nómina de los empleados.

Un abend (de abnormal end) es el sistema deteniendo tu programa a media ejecución porque pasó algo que le impide seguir. Esta guía te enseña a leerlo. La ficha de cada código tiene el detalle; aquí está el método.

Qué es un abend y qué no lo es

Un programa puede terminar mal de cuatro maneras distintas, y se diagnostican distinto. En la tabla, LE es Language Environment, la capa que ejecuta tu programa COBOL:

Qué pasó Quién lo decidió Cómo se ve El programa…
Abend El sistema o LE ABEND=S0C7 en el JESMSGLG Se detuvo a medias.
Return code alto Tu programa COND CODE 0008 en el JESYSMSG Terminó y avisó.
SQLCODE negativo Db2 Solo si tu programa lo muestra Sigue vivo. Tú decides.
File status distinto de 00 El manejo de archivos Solo si tu programa lo muestra Sigue vivo. Tú decides.

El abend es el único que no decidió tu programa. El step se detuvo donde estaba, sin GOBACK y sin cerrar nada por las buenas. Un return code alto, en cambio, lo pone el programa a propósito con MOVE 8 TO RETURN-CODE y el step termina normal; el sistema lo reporta con IEF142I y su COND CODE.

Un SQLCODE negativo es Db2 respondiendo “no pude” a una sentencia, y un file status distinto de 00 es lo mismo con archivos: el programa sigue, y es él quien tiene que mirar ese código y decidir. Las fichas SQLCODE 0 y file status 00 cuentan cómo se leen.

Ojo con esto: un SQLCODE o un file status que nadie revisa puede acabar en abend, o en algo peor: un resultado malo sin ningún aviso. Si un OPEN falla y el archivo no tiene FILE STATUS ni declarativas (la sección DECLARATIVES, que atrapa los errores de archivo), Language Environment lo reporta con IGZ0035S y termina el programa con un U4038. El abend es el síntoma; la causa es el archivo.

Dónde mirar en la salida del job, en este orden

Abre la salida del job en SDSF o en la herramienta de tu instalación. Vas a mirar tres lugares, siempre en este orden, y cada uno te da una pieza:

  1. JESMSGLG: qué step y qué código. Es el log del job. Busca la palabra ABEND:

    IEF450I PRUEBA01 PASO02 - ABEND=S0C7 U0000 REASON=00000007

    Ya sabes que tronó PASO02, con abend de sistema 0C7 y reason code 7. Si tu job tiene varios steps, este es el que importa; los de después seguramente no corrieron.

    Si el abend es de archivo (un S013, un SB37) o de un módulo que no se encontró (un S806), el mensaje con la explicación sale justo arriba de esa línea: un IEC con el DD y el dataset, o el CSV003I con el nombre del módulo. Léelo antes de seguir.

  2. JESYSMSG: los mensajes del sistema. Aquí vienen la asignación de cada archivo del step, los mismos mensajes IEC y CSV del paso anterior, y la confirmación del abend con IEF472I. Para un abend de programa, como el S0C7, aquí no hay más que ver.

  3. SYSOUT del step: el mensaje de Language Environment. Cuando el sistema interrumpe al programa, LE lo atrapa, escribe un mensaje CEE con el offset donde falló (la distancia desde el inicio del programa hasta la instrucción) y, según la configuración, un CEEDUMP: un reporte con los programas activos al momento del error. Los mensajes van al DD SYSOUT y el dump al DD CEEDUMP, o al SYSOUT del job si ese DD no existe.

    CEE3207S The system detected a data exception (System Completion Code=0C7).
             From compile unit CALCNOM1 at entry point CALCNOM1 at compile unit offset +000004C6
             at entry offset +000004C6 at address 1A8004C6.

Con eso tienes el programa, el tipo de error y el offset. El resto de la guía es convertir ese offset en una línea.

Ojo con esto: si el JCL tiene un DD SYSUDUMP o SYSABEND, el sistema también escribe un dump completo de la memoria. Es enorme y hoy no lo necesitas. Algunas instalaciones tienen herramientas que lo analizan por ti y te dan la línea directamente; si la tuya la tiene, úsala, pero aprende el camino a mano, que funciona en todas.

Cómo se lee el código

El código del abend tiene dos sabores, y se distinguen por la letra:

  • Sxxx, abend de sistema. Lo lanzó z/OS o uno de sus componentes. Son tres dígitos hexadecimales: el 0C7 se lee “cero, ce, siete”, no “ciento siete”, y existen el 0CB o el B37. Están documentados en z/OS MVS System Codes y en nuestras fichas.
  • Unnnn, abend de usuario. Lo lanzó un programa, no el sistema: Language Environment, Db2, o un programa de tu instalación. Son cuatro dígitos decimales. El más común es el U4038, que es LE diciendo “pasó algo grave que nadie atendió”; la causa real está en el mensaje CEE o IGZ anterior.

En el mensaje del sistema salen los dos: ABEND=S0C7 U0000 quiere decir sistema 0C7 y usuario cero. Solo uno de los dos es distinto de cero.

Los abends de la familia 0Cx son los que más vas a ver en COBOL: el procesador interrumpió una instrucción y nadie la atendió. IBM documenta que el último dígito dice la causa:

Código Qué detectó el procesador
S0C1 Una instrucción que no existe.
S0C4 Un acceso a memoria que no le toca.
S0C7 Un dato numérico inválido.
S0CB Una división decimal entre cero.

El reason code es la segunda mitad del código. Anótalo siempre junto al código. Lo que te dice depende del abend:

  • En la mayoría de los 0Cx repite el último dígito (REASON=00000007) y no aporta nada.
  • El S0C4 es la excepción: tiene varios reason codes documentados (4, 10, 11) que distinguen qué tipo de acceso falló.
  • En un S013, el 18 es un miembro que no existe y el 20 un BLKSIZE que no cuadra.
  • En un S04E, el reason code es lo único que vas a buscar.

Del abend a la línea del fuente

Esta es la parte que Cómo leer un listado de compilación dejó pendiente. El mensaje CEE te dio un offset: la distancia, en hexadecimal, desde el inicio del programa hasta la instrucción que falló. Hay un camino principal con dos paradas.

Primera parada: el traceback del CEEDUMP. Al principio del CEEDUMP viene la lista de programas activos, del más reciente al más antiguo:

Traceback:
  DSA   Entry      E Offset    Statement   Load Mod   Program Unit   Service   Status
    1   CEEHDSP    +00004AE2               CEEPLPKA   CEEHDSP        HLE77D0   Call
    2   CALCNOM1   +000004C6               CALCNOM1   CALCNOM1                 Exception

Busca la fila con Exception en la columna Status: ese es el programa que tronó y E Offset es el mismo offset del mensaje. Si el programa se compiló con la opción TEST, la columna Statement trae el número de línea y ya terminaste. Si viene vacía, como aquí, sigue a la segunda parada. (Las filas de arriba, CEEHDSP y compañía, son LE atendiendo el error; ignóralas.)

Segunda parada: el listado de OFFSET. Compila el programa con la opción OFFSET, y al final del listado aparece la lista condensada de la PROCEDURE DIVISION: para cada sentencia, su línea, el offset donde empieza su código y el verbo:

LINEID  HEXLOC  VERBCODE    LINEID  HEXLOC  VERBCODE    LINEID  HEXLOC  VERBCODE
000301  000458  READ        000302  000476  IF          000303  000484  PERFORM
000306  0004B8  ADD         000307  0004D0  ADD         000308  0004DC  MOVE

Tu offset es 4C6. Busca el último HEXLOC menor o igual a él: 4B8, que pertenece a la línea 306. El siguiente, 4D0, ya es la 307. La sentencia que tronó es la de la línea 306 del listado.

Ojo con esto: el offset es del listado que corresponde al load que corrió. Si compilaste otra vez después del abend, aunque sea con un cambio chico, los offsets ya no coinciden. Usa el listado de esa compilación o reproduce el abend con el load nuevo.

Tres opciones más que vas a ver mencionadas, sin procedimiento: LIST saca el código máquina generado para cada sentencia, por si el offset cae a la mitad de una línea larga y quieres saber en qué parte. MAP lista cada campo de la DATA DIVISION con su posición, para encontrarlo en un dump. Y TEST guarda información de depuración en el load: con ella el traceback trae el número de sentencia y el CEEDUMP incluye las variables con su valor. Si tu instalación la permite en desarrollo, te ahorra la segunda parada.

Práctica: un S0C7 en CALCNOM1

Lanzaste CALCNOM1 sobre el archivo de nómina de la quincena y el job terminó con ABEND=S0C7. Vas por los tres lugares en orden.

JESMSGLG. IEF450I PRUEBA01 PASO02 - ABEND=S0C7 U0000 REASON=00000007. Tronó PASO02, el que ejecuta CALCNOM1. Sistema 0C7: dato numérico inválido.

JESYSMSG. IEF472I PRUEBA01 PASO02 - COMPLETION CODE - SYSTEM=0C7 USER=0000 REASON=00000007. Nada de archivos ni de módulos. Es un abend de programa.

SYSOUT del step. El CEE3207S de arriba: compile unit offset +000004C6. El traceback no trae Statement, así que vas al listado de OFFSET y llegas a la línea 306:

000305                200-ACUMULA-EMPLEADO.
000306                    ADD WS-IMPORTE TO WS-TOTAL-NOMINA                                    140 121
000307                    ADD 1 TO WS-CONTADOR                                                 122

Ahora razonas, no adivinas. Un S0C7 en un ADD significa que uno de los dos operandos trae algo que no es número. La columna de la derecha, que agrega XREF, te dice dónde se define cada uno:

000120                01  WS-TOTALES.
000121                    05  WS-TOTAL-NOMINA      PIC S9(9)V99 COMP-3.
000122                    05  WS-CONTADOR          PIC 9(5).
...
000136                01  WS-EMPLEADO.
000137                    05  WS-NUM-EMPLEADO      PIC 9(6).
000138                    05  WS-NOMBRE            PIC X(40).
000139                    05  WS-TIPO-EMPLEADO     PIC X.
000140                    05  WS-IMPORTE           PIC S9(7)V99 COMP-3.

WS-TOTAL-NOMINA lo pone en cero el párrafo de inicio y solo lo toca este ADD: no es sospechoso. WS-IMPORTE vive en WS-EMPLEADO, y WS-EMPLEADO se llena con un READ ENTRADA INTO WS-EMPLEADO que nadie valida. El sospechoso es el campo que viene de fuera.

Abres el archivo de entrada en ISPF con HEX ON. WS-IMPORTE es un COMP-3 de cinco bytes y ocupa las posiciones 48 a 52 del registro. Un importe sano, 12500.00, se ve así en hexadecimal: 00 12 50 00 0C, los dígitos empacados y una C de signo positivo al final. Buscas un registro que no cumpla eso, por ejemplo con FIND X'4040404040' 48 52, y aparece:

000038 000475ROSA MENDEZ TORRES                      E
       FFFFFFDDEC4DCDCCE4EDDDCE4444444444444444444444C44444
       0004759621045545903699520000000000000000000000500000

Con HEX ON, debajo de cada carácter ves sus dos nibbles: arriba el alto y abajo el bajo. Las últimas cinco columnas, posiciones 48 a 52, traen 4 arriba y 0 abajo: cinco espacios, 40 40 40 40 40, donde iba el importe. El último nibble, que debía ser C o D, es un 0: no es un signo válido, y con las opciones por omisión del compilador el ADD truena en cuanto lo toca. El registro 38 vino de otro sistema que dejó el importe en blanco para una empleada sin movimientos en la quincena.

La corrección va en dos niveles. En el programa, valida antes de operar y rechaza lo que no sea número, para que un dato malo no tire la nómina completa:

       200-ACUMULA-EMPLEADO.
           IF WS-IMPORTE IS NUMERIC
              ADD WS-IMPORTE TO WS-TOTAL-NOMINA
              ADD 1 TO WS-CONTADOR
           ELSE
              PERFORM 9000-REGISTRA-RECHAZO
           END-IF.

La prueba IS NUMERIC sirve también para COMP-3: revisa que cada dígito esté entre 0 y 9 y que el signo sea válido. Y en el origen, que es el arreglo de verdad: quien genera el archivo tiene que mandar ceros empacados, no espacios, cuando no hay importe. Si no lo corriges ahí, el rechazo te lo va a recordar cada quincena.

Si quieres ir más lejos: si el programa se compiló con TEST, el CEEDUMP trae una sección de variables con el valor de cada campo al momento del abend, y ahí ves los 40 sin abrir el archivo. Sin TEST, se puede llegar al mismo dato con MAP, que da la posición de cada campo, y la memoria del programa en el dump. Es el camino largo; déjalo para cuando el campo culpable no sea tan evidente.

Los que más vas a ver

Una línea por abend y la ficha con el detalle. Fíjate en la última columna: los de programa se resuelven con el offset; los del sistema y de archivos, con el mensaje y el reason code.

Código Qué pasó Por dónde empezar
S0C7 Dato numérico inválido. Offset y campo de origen.
S0C4 Memoria que no le toca: subíndice o CALL. Offset y subíndices.
S0CB División decimal entre cero. Offset y el divisor.
S0C1 Saltó a donde no hay código. Offset y el linkedit.
U4038 LE terminó por un error sin atender. Mensaje CEE o IGZ.
S806 Módulo no encontrado. CSV003I y la STEPLIB.
S013 Error al abrir un archivo. IEC141I y reason code.
S001 Error de entrada/salida. IEC020I.
SB37, SD37, SE37 Sin espacio para seguir escribiendo. IEC030I, IEC031I o IEC032I, y el SPACE.
S322 Se acabó el tiempo de CPU. Contadores y PERFORM.
S222 Alguien canceló el job. Preguntar quién y por qué.
S722 Demasiadas líneas de salida. Un DISPLAY en un ciclo.
S878 No alcanzó la memoria de la región. REGION del JCL.

Rutina paso a paso

  1. JESMSGLG. Busca ABEND. Anota step, código y reason code.
  2. Decide la rama por el código. Familia 0Cx o U4038: abend de programa, rama A. Todo lo demás (806, x13, x37, 322, 222, 722, 878): abend del sistema o de archivo, rama B.

Rama A: abend de programa.

  1. SYSOUT del step. Lee el mensaje de LE: CEE en un 0Cx, CEE o IGZ en un U4038.
  2. Si es U4038, el mensaje es la causa. Un IGZ0035S es un archivo que no abrió; un CEE3501S, un módulo que no se encontró. Se resuelve con el DD o el nombre que trae el mensaje y no hay offset que buscar. Termina aquí.
  3. Si es 0Cx, anota el offset del mensaje CEE y sigue.
  4. Traceback del CEEDUMP. Fila Exception. Si trae Statement, esa es la línea.
  5. Listado de OFFSET si no. Último HEXLOC menor o igual al offset: esa es la línea.
  6. Lee la sentencia y pregunta de cada campo: ¿quién lo llena? El que viene de fuera sin validar es el sospechoso.
  7. Ve al dato de origen: el archivo, la tabla o el parámetro. Corrige el programa para que rechace el dato malo y corrige el origen para que no lo mande.

Rama B: abend del sistema o de archivo.

  1. JESMSGLG, arriba de la línea ABEND. Ahí está el mensaje que lo explica: IEC, CSV, IEF. Trae el DD o el módulo con nombre. Si no lo ves, búscalo en el JESYSMSG.
  2. Reason code y ficha. Con los dos tienes el diagnóstico; no hay offset que buscar.
  3. Corrige el JCL o el dataset y relanza. Si el job dejó archivos a medias, revisa sus disposiciones antes.

Resumen

  • Un abend lo decide el sistema o LE, no tu programa. SQLCODE y file status son avisos que tu programa debe revisar; si no lo hace, sigue con datos malos o termina en abend. El return code, en cambio, lo pone tu programa a propósito.
  • Tres lugares en orden: JESMSGLG para el step, el código y el mensaje IEC o CSV que lo acompaña; JESYSMSG para la asignación de archivos y el IEF472I; SYSOUT del step para el mensaje CEE y el CEEDUMP.
  • Sxxx es del sistema y va en hexadecimal; Unnnn es de un programa y va en decimal. El reason code decide el diagnóstico en los abends de archivo.
  • Del offset a la línea: columna Statement del traceback si hay TEST; si no, el último HEXLOC menor o igual al offset en el listado de OFFSET.
  • En la sentencia que tronó, el culpable casi siempre es el campo que viene de fuera sin validar. Confírmalo en el dato de origen, no adivines.
  • Valida con IS NUMERIC antes de operar, y corrige el origen del dato, no solo el síntoma.