Interrupteur de batch

Feature: 2026-02-17-autostop

Aperçu

L’interrupteur de batch permet de suspendre le lancement d’un programme spécifique dans une chaîne, sans intervention utilisateur. Lorsqu’un programme est ainsi suspendu, un fichier contenant son PID (identifiant de processus) est produit : en utilisant cette information, un débogueur tel que gdb ou celui inclus dans SuperBOL Studio peut alors être attaché au programme, afin d’analyser son comportement.

Prérequis

Les programmes à interrompre et analyser doivent être compilés en mode débogage (option -g) avec un compilateur GnuCOBOL modifié. Les fichiers C intermédiaires générés par GnuCOBOL doivent être accessibles au débogueur.

Fonctionnement

Préalablement au lancement de la chaîne, la liste des programmes à interrompre doit être renseignée dans la variable d’environnement COB_STOP_JOBS. Il peut s’agir de noms de programmes tels que spécifiés par une clause PROGRAM-ID, ou de noms de fichiers exécutables (pour les programmes compilés comme des exécutables avec l’option -x de GnuCOBOL). Les différents noms de programmes doivent être séparés par une virgule.

Le nom du fichier utilisé pour stocker le PID du programme interrompu peut être personnalisé grâce à la variable COB_JOB_PIDFILE. En son absence, le fichier sera nommé $EXECUTABLE-$JOB.pid, où $EXECUTABLE correspond au nom du fichier exécutable (cobcrun pour un module), et $JOB correspond au nom du programme tel qu’il apparaît dans la clause PROGRAM-ID.

La chaîne peut ensuite être exécutée normalement. Lorsqu’elle est interrompue,le débogueur gdb peut être attaché au programme à l’aide de la commande :

$ gdb -p $(cat fichier.pid)

Ou, si l’on préfère passer par gdbserver plutôt que gdb :

$ gdbserver --attach :port $(cat fichier.pid)

Au démarrage de la session de débogage, le programme est arrêté dans un appel à la fonction raise de la librairie standard C. Pour remonter jusque dans le programme COBOL (du moins dans sa traduction en C), on peut utiliser la commande finish (appuyer plusieurs fois sur la touche entrée pour répéter la commande).

Le débogueur inclus dans SuperBOL Studio peut également être attaché au programme, en renseignant le PID correspondant (se référer à la documentation de SuperBOL Studio).

Exemple

On suppose que l’on a un fichier prog.cob contenant deux programmes dont les PROGRAM-ID sont prog1 et prog2, et un fichier sousprog.cob contenant un programme dont le PROGRAM-ID est sousprog. Le programme prog1 appelle prog2 et sousprog à l’aide d’un CALL.

On compile les programmes comme suit :

$ cobc -g -x prog.cob
$ cobc -g -m sousprog.cob

On obtient deux fichiers binaires prog et sousprog.so. L’option -g permet d’intégrer les informations de débogage à ces deux fichiers binaires, ainsi que de conserver les fichiers C intermédiaires.

On veut interrompre les appels aux programmes prog1, prog2, et sousprog. Pour ce faire, on configure la variable d’environnement COB_STOP_JOBS :

$ export COB_STOP_JOBS=prog1,prog2,sousprog

A noter que puisque tous les programmes contenus dans le fichier exécutable prog sont concernés, on aurait également pu écrire :

$ export COB_STOP_JOBS=prog,sousprog

On lance alors le programme :

$ ./prog

Son exécution est alors silencieusement interrompue. A l’aide d’un autre terminal, on cherche le fichier contenant le PID du processus :

$ ls *.pid
prog-prog1.pid

L’exécution s’est donc bien interrompue sur le programme prog1. On attache le débogueur :

$ gdb -p $(cat prog-prog1.pid)

Le débogueur affiche :

Program received signal SIGTSTP, Stopped (user).
__pthread_kill_implementation (no_tid=0, signo=20, threadid=140599531862272) at ./nptl/pthread_kill.c:44
44    ./nptl/pthread_kill.c: Aucun fichier ou dossier de ce type.
(gdb) 

A l’aide de la commande finish, on remonte jusqu’au code du programme :

(gdb) finish       (appuyer plusieurs fois sur entrée)

On obtient :

Run till exit from #0  0x00007fdfe1cf1c10 in cob_set_cancel () from /opt/gnucobol-sb/lib/libcob.so.4
prog1_ (entry=0) at prog.c:185
185      b_2 = 0;
(gdb) 

A partir de là, on peut explorer l’exécution du programme prog1.

Si l’on poursuit l’exécution (commande continue de gdb), celle-ci va de nouveau s’arrêter automatiquement sur prog2, puis sousprog, produisant les fichiers prog-prog2.pid et prog-sousprog.pid (le PID ne change bien évidemment pas, mais la présence du fichier permet de savoir quel programme a été interrompu).

A noter que si prog.cob avait été compilé comme un module plutôt que comme un exécutable, les fichiers PID produits se seraient nommés cobcrun-prog1.pid, cobcrun-prog2.pid, cobcrun-sousprog.pid.