Abend codes frequently involve a SuperVisor Call (an SVC), but not always. The
E37 doesinvolve an SVC.
By far the majority of the instructions in your program deal with moving data
around and performing calculations. This is true if you write in assembler or a
high-level language, or even when you use a utility program.
But occasionally you want to do something that has been done bunches of times
by those who preceed you, and you do not want to reinvent the wheel (much less
re-debug the wheel), so you invoke a standard routine to do it for you. In a
high-level language this might look like an OPEN, a READ, a WRITE, or a CLOSE
verbs. In assembler these would be macros.
Many of the basic Input/Output operations are delivered as canned routines by
the hardware vendor, being built into the machine itself. In fact for
protection, I/O operations can only be performed in supervisor mode (in
contrast to your program's problem state). So the high-level verbs or macros
resort to a SuperVisor Call (an SVC, known also as a SerVice Call).
There are many of these, they are called by a number (which is actually
hexadecimal). Such an instruction might look like
It is like a punt, the operating system catches it, takes care of it and when
complete, returns control to your program.
SVC 13, for example is an OPEN. SVC 37 is a close.
It turns out that your READs and WRITES, which ultimately are SVCs as well,
can themselves invoke a CLOSE (SVC 37) if they get into deep trouble. ((So to
avoid confusion when you try to apply these concepts to your source code, you
did not make it to _your_ source code CLOSE verb!))
"End of Volume" processing is a bit of an anachronismic term. In virtual
systems you are rarely concerned with physical limits like the actual physical
end of a tape or disk volume (but it definitely does happen sometimes).
Instead you are at the end of the logical limit permitted for that dataset.
"End of Volume" processing, sometimes abbreviate EOV, simply means the point at
which you closed the file or the royal WE closed it for you becasue it was in
trouble because of a lack of space.
There are various reasons you can run out of space, and the reason code is
returned in the abend code: the common B37, D37 and E37 reflect the reason (or
Some mainframe shops have a support program that helps take the mystery out of
these abends (I think it is called X37, a product or program name, not another
When you get a 37 abend in a _new_ program, even as an experienced programmer,
you have an immediate hint that your program is looping infinitely (but not
necessarily). During development, programmers will often insert temporary
displays inside of loops to find a clue as to where things are going wild.
Another thing that happens early in development of a program, even for
experienced coders, is that after a few false starts, the program finally takes
off ... but the allocation on the datasets has been way too timid, and a good
run just busts past the limit.
So up the allocation in the SPACE=(...) parameter in the execution JCL.
You will learn to recognize when the abend code has an SVC in the lower two
digits and when it does not (the 0C4s and 0C7s are not reflective of SVCs, for
By the way, there are many S/390s, and many well paid workers attending them.