JCL
JOB CONTROL LANGUAGE
EXEMPLO
// JOB1 JOB (034D),'RAMESH',CLASS='A',PRTY=6
// STEP01 EXEC PGM=COBPROG.
// INFILE DD DSN=SED.GLOB.DES.INFILE,DISP=SHR
// OUTIFLE DD DSN=SED.GLOB.DES.OUTFILE,
// DISP=(NEW,CATLG,DELETE),
// UNIT=DISK,
// SPACE=(CYL,(1,5),RLSE),
// DCB=(RECFM=FB,LERECL=70,BLKSIZE=700)
ESTE JCL FOI CRIADO PARA RODAR UM PROGRAMA DE COBOL
JCL SINTAXE
O JCL é escrito entre as colunas 1 – 71 (exceto comentários). Frequentemente as colunas 73 – 80 são usadas para números seqüenciais.
Para se continuar uma linha com mais de 71 caracteres (exceto comentários), a primeira linha é terminada com vírgula, e a próxima linha deverá começar entre as colunas 4 e 16 sem esquecer de colocar as duas barras (//) nas linhas 1 e 2.
ESTRUTURA JCL
Toda a estrutura deve começar com duas barras (//) entre as colunas 1 e 2.
“//*” significa um comentário, uma parte escrita e não é usado, é apenas informativo.
“/*” é usado para finalizar uma sessão de entrada de dados, o mesmo parâmetro para algumas outras funções como o comando XEQ que indica em qual sistema o JES executará o Job.
Os CAMPOS do JCL
// (será usado sempre nas colunas 1 e 2 )
Name Field (nome específico para o job)
Operation Field (indica a operação a ser executada)
Operand ( complementos do Operation Field)
Comments (comments começam 1 espaço depois do ultimo Operand, também podemos colocar os comentários após “//*”)
Exemplo:
// Name Operation Operand
// JOB1 JOB (034D),'RAESH',CLASS='A',PRTY=6
// STEP01 EEC PGM=COBPROG
// INFILE DD DSN=SED.GLOB.DES.INFILE,DISP=SR
// OUTIFLE DD DSN=SED.GLOB.DES.OUTFILE,
// DISP=(NEW,CATLG,DELETE),
// UNIT=DISK,
// SPACE=(CYL,(1,5),RLSE),
// DCB=(RECFM=FB,
// LERECL=70,BLKSIZE=700)
Quando o Job processa, ele lê o JCL de maneira simples de cima para baixo. Quando tem uma vírgula,isso significa que o campo operacional tem continuação na ação, quando não tem virgula, quer dizer que a próxima ação será em outro cartão do Job, mas ainda no mesmo Step.
Tipo de Cartões
São tres os cartões do Job:
Job Card - É usado principalmente para identificar o job, e diz ao MVS que tipo de job é, e qual a prioridade do mesmo.
EXEC CARD - É usado para especificar o programa a ser usado.
INFILE é nome do DD CARD - Determina o arquivo de entrada, ou seja, de onde será retirado as informações necessárias para que seja executado o programa.
OUTFILE é o mesmo que INFILE - Um exemplo de DD Card.
JOB CARD
O JOB Card é a primeira parte do job e indica tanto o inicio do mesmo quanto informações sobre o cliente, programador, nome e alguns parâmetros que também darão informações de como o job irá funcionar
Componentes do cartão Job
JOB NAME
Nome do job e seu identificador para o sistema. Deve ser colocado sempre na coluna 3 e tem tamanho máximo de 8 caracteres.
OPERATION FIELD
É o JOB, este parâmetro é fixo e serve para identificar o tipo de operação a ser realizada naquela linha.
INFORMAÇÕES DA CONTA E DO NOME DO PROGRAMADOR
Estes dois parâmetros são posicionais, não aparecem em todos os JCL’s
CLASS
É USADO PARA DIZER AO SISTEMA PERACIONAL QUAL A NATURAZA DO JOB.
SINTAXE - CLASS = classe do job.
VALORES VÁLIDOS - QUALQUER CARACTERE ALFABÉTICO ENTRE A E Z OU NUMERAL ENTRE 0 E 9.
PRTY
Este parâmetro designa uma prioridade para os JOBS de mesma classe. Quanto maior o numero da classe, maior e a prioridade deste JOB rodar sobre os outros que continuarão aguardando a execução do mesmo.
Sintaxe - PRTY= prioridade.
Valores Válidos - qualquer valor entre 0 e 15.
MSGCLASS
Este parâmetro determina o dispositivo de saída para onde serão escritas as mensagens do sistema e do JCL.
Sintaxe - MSGCLASS=nome da classe de saída.
Valores válidos - Qualquer caractere alfabético entre A e Z ou numeral entre 0 e 9. O tipo de classe e suas definições são criadas pelo sistema operacional ou pelo grupo de suporte.
MSGLEVEL
Usado para dizer ao JCL quais mensagens deverão ser “impressas” no dispositivo especificado no parâmetro MSGCLASS.
Sintaxe - MSGLEVEL=(partes a serem “impressas” (statements), mensagens).
Valores válidos - partes a serem impressas ou statements, podem ser números 0, 1 ou 2 e as mensagens podem ser 0 ou 1.
Statements:
0 – Imprimira apenas os relatórios do job.
1 – O JCL será impresso (incluindo todos os parâmetros catalogados / simbólicos).
2 – So imprimira os inputs do JCL.
Mensagens:
0 - As mensagens de Alocação e finalização serão impressas caso o job termine com erro.
1 - As mensagens de Alocação e finalização serão impressas caso o job termine em erro ou não.
REGION
Este parâmetro especifica a máxima quantidade de armazenamento virtual que o job poderá usar. Uma certa quantidade de K ou M deve ser especificado, as limitações deste espaço são definidos pela classe do job.
Sintaxe - REGION=xxxxK ou M.
Valores válidos - Qualquer caractere numérico desde que de acordo com as especificações da classe.
TIME
Este parâmetro especifica o total de CPU time a ser usado pelo job (em minutos, segundos) este número e para todos os steps do job. O valor máximo permitido geralmente é de até 1439 minutos, caso o valor especificado seja igual a 1440, isso indicará que o job não possui limite de tempo.
Sintaxe - TIME=(minutos,segundos)
Valores válidos - Qualquer caractere numérico indicando tempo ate 1440, unidades não são usadas neste parâmetro.
TYPRUN
Quando este parâmetro e usado o Job não rodara propriamente, ele possui dois tipos SCAN ou HOLD, o primeiro fará uma checagem no job e o segundo o manterá em HOLD ate segunda ordem.
Sintaxe - TYPRUN=HOLD (job em HOLD até segunda ordem), TYPRUN=SCAN (checa o JCL para possíveis erros de sintaxe)
Valores válidos - HOLD ou SCAN
NOTIFY
Este parâmetro é usado para indicar ao sistema, onde as mensagens de sucesso ou de falha devem ser enviadas após o job completar.
Sintaxe - NOTIFY=userid / &SYSUID
Valores válidos - userid é o ID de quem o submeteu, &SYSUID representa o ID de quem o submeteu.
A diferença e que no caso de um &SYSUID o job localizará quem liberou o job e manda o Report para ele e o outro caso o job manda um report sempre para uma pessoa.
Cartão JOBLIB e STEPLIB
JOBLIB
Uma espécie de cartão DD (Data Definition), e especifica onde o programa existe. É aplicável a todos os steps daquele job.
Sintaxe - // JOBLIB DD DSN=dataset
Exemplo de JCL:
// MYJOB JOB (E343),'KRISHNA'
// JOBLIB DD DSN=SE.TST.LODLIB,DISP=SHR
// STEP1 EXEC PGM=COBPROG
Logo após o JOB card esta o JOBLIB DD, que especificara a localização do programa que será executado.
STEPLIB
Muito parecido com o JOBLIB, este DD pode ser usado em qualquer ponto do step.
A DIFERENÇA ENTRE O STEPLIB E O JOBLIB É QUE O STEPLIB ESPECIFICA A LOCALIZAÇÃO DO PROGRAMA A SER USADO APENAS NAQUELE STEP.
Sintaxe - // STEPLIB DD DSN=dataset
EXEMPLO DE JCL:
// MYJOB JOB (U456),'KRISHNA'
// STEP1 EXEC PGM=COBPROG
// STEPLIB DD DSN=TEST.MYPROD.LIB,DISP=SHR
// STEP2 EXEC PGM=COBPROG2
// STEPLIB DD DSN=TEST.MYPROD.LIB1,DISP=SHR
No exemplo acima, STEP1 está executando COBPROG o qual é membro de TEST.MYPROD.LIB.
E o STEP2 está executando COBPROG2 o qual é membro de TEST.MYPROD.LIB1.
OBS: Caso existam um JOBLIB e um STEPLIB no mesmo job, as especificações do STEPLIB terão prioridade no step e serão executadas.
CARTÃO EXEC
O cartão EXEC é usado para executar um programa (PROG), ou uma procedure (PROC). O máximo de STEPS que podem existir em um JCL só será 255, caso sejam necessários mais
STEPS, estes devem figurar em outro JOB, colocando-o para rodar logo após o primeiro JOB da série.
Sintaxe - // stepname EXEC PGM=progname, PARM='parm', COND=condition, REGION=n, TIME=(m,s)
Programa (PROG)
É simplesmente um programa a ser executado, dependendo do que o programa realizará alguns dados serão necessários e estes serão fornecidos pelo DD card que veremos em seguida.
Parm field (PARM)
É um parâmetro usado para passar alguma informação para o programa.
Sintaxe - PARM=valor
Valores válidos - O valor é uma cadeia de caracteres ou “strings” de 1 a 100 caracteres de tamanho.
Procedure (PROC)
Procedures são coleções de JCL pré definidos catalogados e armazenados, são chamados pelo JOB com o uso de um código próprio. Existem duas maneiras de usarmos uma procedure em um JCL, das quais a segunda forma é a mais utilizada.
Ex1: // procstepname EXEC PROC=procname,param1=foo
Ex2: // procstepname EXEC procname,param1=foo
REGION
Especifica a quantidade de espaço que devera ser usado na hora de rodar aquele Job/Step.
Sintaxe - REGION=< valor >K ou REGION=< valor >M
Exemplo de JCL:
// MYJOB JOB (AE32),'RAMESH'
// STEP1 EXEC PGM=COBPROG,
// REGION=67K
Para deixar disponível todo armazenamento disponível é só usar 0K ou 0M no parâmetro REGION.
COND
Cada STEP envia ao sistema um “return code” ao completar, este é chamado “condition code”. O parâmetro COND é usado para controlar a execução dos steps seguintes, dependendo do “condition code“ que vem do step anterior. Os return codes variam entre 0 e 4095.
Sintaxe - COND=(comparsion code,condition), COND=(comparsion-code,condition), (If coded on step), [,stepname] [,EVEN / ONLY]) , (If coded on step)
As condições podem ser:
GT = Greater Than
GE = Greater or EqualL
T = Lower or ThanL
E = Lower or Equal
EQ = Equal
NE = No Equal
Exemplo de JCL:
// MYJOB JOB (R475),'KRISHNA REDDY‘, COND=(4,GT)
// STEP1 EXEC PGM=COBPROG
// STEP2 EXEC PGM=COBPROG2
Neste exemplo estamos dizendo ao JCL que se o STEP1 tiver um return code maior que 4 então o STEP2 será passado sem executar, ou seja, pulado (BYPASS).
// MYJOB JOB (U769),'KRISHNA REDDY'
// STEP1 EXEC PGM=PROG1
// STEP2 EXEC PGM=COBPROG, COND=(8,EQ,STEP1)
Neste exemplo veremos que o STEP2 será pulado (BYPASS) caso o STEP1 terminar um return code igual a 8.
TIME
O parâmetro TIME é usado para especificar a quantidade de CPU time que um job ou um step poderá utilizar.
A sintaxe deste parâmetro e a mesma que a do cartão JOB descrito anteriormente. Não podemos esquecer de alguns dados importantes para este parâmetro:
Minutes pode ser de 1 a 1439, Segundos pode ser de 1 a 59
// SECOND JOB,'R. KRISHNA',TIME=3
// STEP1 EXEC PGM=C,TIME=2
// STEP2 EXEC PGM=D,TIME=2
Neste exemplo temos um job com tempo total de limite de 3 minutos, e cada um de seus steps possue dois minutos para rodar, caso o STEP1 levar dois minutos, o STEP 2 só terá 1 minuto para rodar, porque o JOB terá 3 minutos para rodar e as informações do cartão JOB terão prioridade.
Para codificar tempo ilimitado para um job é necessário usar no parâmetro TIME=, o numero 1440 ou NOLIMIT.
Outros parâmetros pouco usados:
ACCT – informações da conta para aquele step.
ADDRSPC – Usado para indicar o tipo de armazenamento que o step usara, pode ser armazenamento virtual ou real.
DPRTY – usado para determiner uma prioridade para aquele step
PERFORM – especifica a taxa de recursos a ser usado pelo step.
RD – (Restart Definition) é usado para determiner o restart automatico de um Job caso ele abend.
CARTÃO DD
O cartão DD (Data Definition), é usado para identificar os recursos de entrada e os locais de armazenamento de “output”.
Sintaxe - // ddname DD < Parâmetros posicionais / de comando >
Parâmetros Posicionais :
DATA
DUMMY
DYNAM
Parâmetros de Comando :
DSN
DISP
UNIT
SPACE
DCB
VOLUME
Parametros de Comando
DSN
Esse parâmetro é usado para especificar o nome do data set.
Sintaxe - DSN=nome do data set.
Exemplo de JCL:
// MYJOB JOB (ER3),'RAMESH R'
// STEP1 EXEC PGM=COBPROG
// INFILE DD DSN=TEST.GLOB.MYLIB
TEST.GLOB.MYLIB será usado no programa COBPROG.
Data Set temporário – esse tipo de dataset durante a rodada do JOB é deletado no final da execução. Os data sets temporários são codificados usando dois e comerciais (&&) seguidos do nome.
Exemplo de JCL:
// MYJOB JOB (E456),'RAMESH'
// STEP1 EXEC PGM=COBPROG
// INFILE DD DSN=&&TEMP
DISP – o parâmetro DISP é usado para especificar a disposição do data set que será
definido no parâmetro DSN.Sintaxe - DISP=(STATUS,DISPOSICAO NORMAL, DISPOSICAO ANORMAL)
STATUS – status atual do data set (se ele existe ou terá de ser criado)
DISPOSICAO NORMAL – caso o JOB complete bem, como o data set será tratado(deletado, catalogado, etc)
DISPOSICAO ANORMAL – caso o JOB abend, como o data set será tratado(deletado,
catalogado, etc)
Parâmetros DISP
Status - Normal Disp - Abnormal Disp
NEW - DELETE - DELETE
OLD - CATLG - CATLG
MOD - UNCATLG - KEEP
SHR - KEEP - UNCATLG
- PASS
STATUS
NEW - Data set será criado. (file não deve existir)
OLD - Data set deve existir.
MOD - Data set será criado caso não exista.
SHR - Data set não poderá ser usado por outro JOB.
DISPOSICAO NORMAL
DELETE - Data set devera ser deletado.
CATLG - Data set devera ser catalogado.
UNCATLG - Data set será removido dos catálogos do sistema.
KEEP - Data set será guardado, mantido (Este parâmetro deve ser usado com data sets permanentes).
PASS - Data set devera ser passado para o próximo step no job.
DISPOSICAO ANORMAL
DELETE - Dataset será deletado
CATLG - Dataset será catalogado
UNCATLG - Dataset será removido dos catálogos do sistema
KEEP - Dataset sera mantido
Exemplo de JCL:
// MYJOB JOB (E674),'KRISHNA REDDY'
// STEP1 EXEC PGM=COBPROG
// INFILE DD DSN=TEST.GLOB.TEMP, DISP=(NEW,CATLG,DELETE)
UNIT
Em um ambiente mainframe, todos os devices têm um endereço designado no
momento que são adicionados ao sistema. Esses devices podem ser referenciados usando
estes endereços. O parâmetro UNIT é usado para especificar estes endereços.
Sintaxe - UNIT=device_address/device_type/device_group_name/TAPE
Exemplo de JCL:
// MYJOB JOB (R345),'KRISHNA REDDY'
// STEP1 EXEC PGM=COBPROG
// INFILE DD DSN=TEST.GLOB.TEST.LIB,
// UNIT=SYSDA
Neste exemplo o arquivo de entrada TEST.GLOB.TEST.LIB existe em qualquer um dos
devices que estão designados com o nome simbólico de SYSDA.
VOL
Este parâmetro é usado para identificar o numero serial do volume no qual o
Dataset reside. O parâmetro VOL é usado com data sets de disco e tape.
Sintaxe - VOL= volumelabel/data set label
**Sub-parâmetros usados com o parâmetro VOL:__
SER - especificação do número serial.
REF - faz referência a um volume localizado em um step anterior.
PRIVATE - permite o acesso a um volume por apenas um usuário.
RETAIN - não permite que o volume seja desmontado antes do termino do job.
SEQ - especificação da seqüência em que os volumes serão montados.
Exemplo de JCL:
// MYJOB JOB (E454),'KRISHNA REDDY'
// STEP1 EXEC PGM=COBPROG
// INFILE DD DSN=TEST.GLOB.TEMP,
// VOL=SER=(VOL1,VOL2,VOL3)
SPACE
Este parâmetro é usado para alocar espaço para datasets. Podemos alocar espaço em cilindros/tracks/blocos.
Sintaxe - SPACE=(CYL,(primary,secondary,directory),RLSE, CONTIG,MXIG,ROUND)
Significado dos sub parâmetros:
TRK - Espaço estará em tracks.
CYL - Espaço estará em Cilindros.
PRIMARY - Espaço primário a ser alocado quando o data set for criado.
SECONDARY - Espaço adicional a ser alocado caso a alocação primaria não for suficiente, será ampliada 15 vezes caso necessário.
DIRECTORY - Espaço para alocação do nome e localização de datasets particionados.
RLSE - Libera espaço pré-alocado não utilizado, depois que o Job completar.
CONTIG - Requisição para espaços contíguos.
MXIG - Requisição para uma grande área de espaço contíguo.
ROUND - Requisição para armazenamento em um cilindro inteiro.
Exemplo de JCL:
// MYJOB JOB (W345),'KRISHNA REDDY'
// STEP1 EXEC PGM=COBPROG
// INFILE DD DSN=TEST.GLOB.LIB,
// UNIT=4560,
// SPACE=(CYL,(30,4))
DCB
Os dados em um dataset podem ter tamanho fixo ou tamanho variado. O parâmetro DCB (Data Control Block) é usado para especificar o formato da gravação, tamanha da gravação, tamanho de blocos etc…
Sintaxe - // ddname DD DCB=< parameters >
Sub-parâmetros:
RECFM - Especificação do formato dos dados - F/FB/V/VB/U
LRECL - Especificação do tamanho dos dados
BLKSIZE - Especificação do tamanho dos blocos
BUFNO - Especificação do buffers
Exemplo de JCL:
// MYJCL JOB (E3445),'RAMESH'
// STEP1 EXEC PROG=COBPROG
// INFILE DD DSN=TEST.GLOB.LIB,
// UNIT=234,
// DSN=(LRECL=80, RECFM=FB, BLKSIZE=800, BUFNO=30)
Neste exemplo, o parâmetro DCB especifica que este file necessita de uma gravação
lógica de tamanho 80 bytes, terá um formato de bloco fixo, e a quantidade de blocos
será 800. O parâmetro BUFNO está setado para 30 indicando que até 30 buffers poderão
ser utilizados. A quantidade de buffers default é 5 caso não exista o parâmetro BUFNO.
RESTART
O Restart no JCL é usado no cartão job, depois do ultimo parâmetro ou em qualquer parte dos parâmetros não posicionais, utilizar o parâmetro RESTART=PROCSTEP.STEP, não esquecer de adicionar a virgula antes do parâmetro restart.
Sintaxe - ,RESTART=step.procstep,
Exemplo de JCL:
// jobname JOB 'message message message',ZZZ,
// MSGLEVEL=1,MSGCLASS=Q,
// NOTIFY=onono,
// RESTART=step.procstep
CHEKPOINT
O Checkpoint é um parâmetro onde o job lê as informações processadas em um determinado período de tempo e salva este processamento ponto a ponto para posterior conferencia ou até um restart de um determinado ponto do processamento para evitar perda de tempo e informação.
Checkpoint Restart
// jobname JOB (y999,onon),'blabla',REGION=5000K,CLASS=X,
// MSGCLASS=N
// JOBLIB DD DSN=data.set.name,DISP=SHR
// DD DSN=data.set.name.one,DISP=SHR
// DD DSN=data.set.name.two,DISP=SHR
/*JOBPARM F=CJBA
/*ROUTE PRINT RMDS
*LOGONID ononon
OUTD OUTPUT CLASS=*,FORMS=zzzz,DEST=RMDS
// UCC11RMD EXEC UCC11RMD,RUN=P
// zz12347 EXEC zz54321
// zz12348 EXEC zz54322
// zz12349 EXEC zz54323
Job abended message:
JOB99999 MVS0010I jobname 07.234 X step procstep R0012
Depois deve-se procurer o ultimo checkpoint:
JOB99999 +DFS0540I *EXTENDED CHECKPOINT*
PROGRAM=vaivaivai,CKPTID=ididid,REGID=0001,DAY=234,TIME=0447432 IMP9JOB99999
+DFS0542I *EXTENDED CHECKPOINT* DAY=234,TIME=044743277753-0400 IMPX
Depois disso devemos ir no cartao exec do step de abend e la no JCL procurar o nome do Checkpoint:
XX step EXEC PGM=pgmpgmpg,
XX PARM='bla,wwwwwwww,yyyyyyyy00000,&CKPT999'
O parâmetro & indica um parâmetro oculto que será carregado naprocedure, ou mesmo
uma variável que poderá ser refeita com o override.
Após acharmos o nome do checkpoint, devemos ir no step de abend e fazer o seguinte
override:
// jobname JOB (y999,onon),'blabla',REGION=5000K,CLASS=X,
// MSGCLASS=N
* blabla yy0000 LAST SYSTEM ACCESS 22.21-08/21/07 FROM STCINRDR ononon
* CA-7 JOB#=9999 DUE OUT 99.999/99.99 JCLID=000 SCHID=999 ENTRY=AUTO
* CA-7 COM9 EXIT02=Y
zz12347 EXEC zz54321,CKPT999=idididid
// zz12348 EXEC zz54322
// zz12349 EXEC zz54323
Este tipo de ação é tomada quando o job não tem o JCL acessível para editar, quando o JCL pode ser editado, é necessário ir no JCL e no local onde hover o checkpoint ID fazer a modificação e restartar do step.
XX step EXEC PGM=DFSRRC00,
XX PARM='bla,wwwwwwww,yyyyyyyy00000,CKPT999=idididid'
Caso o checkpoint seja feito do ultimo ponto onde o “CKPTID=” foi encontrado ou se o operador não tem acesso a essas informações uma solução fácil e eficaz é utilizar o parâmetro LAST da mesma maneira que fizemos com o parâmetro anterior.
// step EXEC proc,CKPT999=LAST
Ou
XX step EXEC PGM=DFSRRC00,
XX PARM='bla,wwwwwwww,yyyyyyyy00000,CKPT999=LAST'
Override para Parametros DD
Para se realizar um override algumas informações precisam ser coletadas.
- Qual o Step de abend.
- Qual o DD onde o override será executado.
- Qual o parâmetro a ser arrumado.
Exemplo:
JOB04603 MVS0010I xxxxxxxx 07.234 X zzzzzzz wwwwwww ** SB37 **
XX SORTOUT DD DSN=xx.zzzzzz,
XX DISP=(,CATLG,DELETE),
XX UNIT=SYSDA,
XX SPACE=(TRK,(700,75),RLSE)
SPACE=(TRK,(700,75),RLSE),
// jobname JOB (9999,zzz99),'zzzzzzz',REGION=5000K,CLASS=X,
// MSGCLASS=N
// * CA-7 COM2 EXIT02=Y
// zz12345 EXEC zz54320
// zz12346.SORTOUT DD SPACE=(TRK,(750,100),RLSE)
// zz12347 EXEC zz54321
// zz12348 EXEC zz54322
// zz12349 EXEC zz54323
Override Para Cartão EXEC
Este override é o mais fácil, bastando para o mesmo apenas o parâmetro necessário para o override e a modificação a ser feita, depois é só ir no JCL e onde esta a chamando a proc, e só colocar virgula e depois colocar o parâmetro a ser mudado, desde que este conste no cartão EXEC daquele step.
// jobname JOB (9999,zzz99),'zzzzzzz',REGION=5000K,CLASS=X,
// MSGCLASS=N
// * CA-7 COM2 EXIT02=Y
// zz12346 EXEC zz54320,CKPT999=LAST
// zz12347 EXEC zz54321
// zz12348 EXEC zz54322
// zz12349 EXEC zz54323
Programas Padrão IBM
São os Programas utilizados no JCL e que realizam determinados trabalhos, updates, copias, etc..
IEBCOPY – Copia, comprime e migra datasets particionados, ele também seleciona ou exclui membros específicos durante a operação de copia e os renomea, ou ate os substitui.
IEBGENER – Copia dados de um dataset seqüencial ou cria datasets particionados
IEFBR14 – é um programa “dummy”, normalmente usado para alocar ou deletar datasets.