You can use svc99() to create //DDNAME entries in a job. I used it to dynamically allocate
//COLIN DD SYSOUT=H
from within my C program.
You cannot use a 31 bit C program in a 64 bit C program
If you try to fetch and use a 31 bit C program in a 64 bit program you get
EDC5256S An AMODE64 application is attempting to fetch() an AMODE31 executable. (errno2=0xC4070068)
It is hard to make this to work, because of 64 bit parameters do not work in a 31 bit program. The save area’s are complex. Overall it is easier to just call a 64 bit program from a 64 bit program and do not try to use a 31 bit. You can do it, but you need some assembler glue code.
svc99 works in both 31 and 64 bit modes because at bind time
- the 31 bit program includes a 31 bit version of svc99
- the 64 bit program includes a 64 bit version of svc99.
The 64 bit program has come glue code to enable it to call the 31 bit program.
Using a 64 bit program with a 31 bit parameter list
Using svc99() was pretty easy from a 31 bit C program, but the documentation says The __S99parms structure must be in 31-bit addressable storage, which is a bit of a challenge.
For the 31 bit C program, the code is like
int main () {
SVC99char1( sysoutClass, DALSYSOU,'A')
SVC99string(ddname,DALDDNAM,"COLIN")
struct __S99struc parmlist;
struct __S99rbx rbx =
{
.__S99EID = "S99RBX",
.__S99EOPTS =0xC4, // issue message before return, and use wto
.__S99EVER =0x01}; // version
memset(&parmlist, 0, sizeof(parmlist));
void *tp[3]= { /* array of text pointers */
&sysoutClass,
&ddname,
0};
int mask = 0x80000000;
memcpy(&p->tp[2],&mask,4); // make it a null address with high bit on
parmlist.__S99RBLN = sizeof(parmlist);
parmlist.__S99VERB = 01; /* verb for dsname allocation */
parmlist.__S99FLAG1 = 0x4000; /* do not use existing allocation */
parmlist.__S99TXTPP = tp; /* pointer to pointer to text units */
parmlist.__S99S99X =&rbx; // pointer to extension
int rc;
rc = svc99(&parmlist);
Where
- SVC99char1(..) and SVC99string(…) define the parameters for SVC 99
- struct __S99rbx rbx defines the request block extension which indicates errors to be reported on the job log
- void tp[3] is the array of parameter for svc 99. The value can be null. The last must have the top bit on, so mask is copied in.
- parmlist is the svc99 parameter list which points to the other data: the definition, and the request block extension.
Getting it to work in a 64 bit C program.
You have to build a parameter list where all the parameters are in 31 bit storage.
Generate the 31 bit structure
I defined a structure to contain the 31 bit elements, then used ___malloc31 to allocate 31 bit storage for it.
struct pl31 {
struct __S99struc parmlist;
struct __S99rbx rbx;
// 31 bit equivilants of the SVC 99 parameters
struct sysoutClass sysoutClass;
struct ddname ddname ;
void * __ptr32 tp[3]; /* array of text pointers */
} pl31;
char * __ptr32 p31 =(char * __ptr32) __malloc31(sizeof(pl31));
The __ptr32 in char * __ptr32 p31= tells C this is a pointer to 31/32 bit storage.
Set up the parameter list
struct pl31 * p ;
p = (struct pl31 * ) p31; // set up 31 bit pointer to data
memcpy(&p->rbx,&rbx,sizeof(rbx)); // copy from static to 31 bit area
memset(&p->parmlist, 0, sizeof(p->parmlist)); // initialise to 0
p->parmlist.__S99RBLN = sizeof(p->parmlist);
p->parmlist.__S99VERB = 01; // verb for dsname allocation
p->parmlist.__S99VERB = 07; // display
p->parmlist.__S99FLAG1 = 0x4000; // do not use existing allocation
p->parmlist.__S99TXTPP =& p->tp ; // pointer to pointer to text units
p->parmlist.__S99S99X =& p->rbx ; // pointer to extension
Create the svc99 definitions in 31 bit storage
The macros SVC99string etc generate code like
struct ddname{
short key;
short count;
short length;
char value[sizeof("COLIN ")]; }
ddname = {0x0001,1,sizeof("COLIN ")-1,"COLIN "};
so within the 31 bit structure I could use
struct ddname ddname;
to allocate a structure the same shape as the original definition.
I then used a macro SVC99COPY(…); which copies the data from the original, static, definition into the 31 bit structure.
#define SVC99COPY(name) memcpy(&p->name,&name,sizeof(name));
Creating and initialising the rbx
Because the 31 bit storage is dynamically allocated, you cannot use structure initialisation like:
struct pl31 {
struct __S99struc parmlist;
struct __S99rbx rbx =
{
.__S99EID = "S99RBX",
.__S99EOPTS =0xC4, // issue message before return, and use wto
.__S99EVER =0x01 // version
};
...
} pl31;
I defined rbx in the mainline code, and copied it into the pl31 structure once it had been allocated.
Set up the pointer to the definitions
p->tp[0] = &p-> ddname ;
p->tp[1] = &p-> sysoutClass ;
int mask = 0x80000000;
memcpy(&p->tp[2],&mask,4);
The array of tp[] has to be initialised at run time, rather than at compile time because the 31 bit storage is dynamically allocated.
Invoke the svc99()
rc = svc99(&p->parmlist);
So overall – not too difficult.
Making the code bimodal
If you want to make a function which can be used from 31 or 64 bit programs. You need to provide two versions of the code. One compiled as a 64 bit program, the other as a 31 bit program. You could have
- myprog() for 31 bit programs and
- myprog64() for 64 bit programs.
or you could specify
#ifdef __LP64
#pragma map (myprog, "myprog64")
#else
#pragma map (myprog, "myprog31")
#endif
...
myprog()
At bind time you need to include the correct code, myprog64 or myprog31.
If could just use the one name, and have two object libraries, and specify the library in JCL, for example
//BIND.OBJLIB DD DISP=SHR,DSN=COLIN.OBJLIB31
//BIND.SYSIN DD *
INCLUDE OBJLIB(MYPROG)
NAME...
If you have used the wrong library at bind time, you may only find out a run time.
If you use the #pragma map to force it to use object names, you will find the problem at bind time, because myprog31 or myprog64 will not be found.
ColinPaice 