C calling an “assembler” function, setting the high order bit on, and passing parameters.

Since days of old when knights were bold, the standard parameter list to call an assembler function was to pass the addresses of the parameters, and set on the top bit of the address for the last address.
This way the called function knows how many parameters have been passed, and you do not need to pass a parameter count.

Setting the high order bit on, for the last parameter

I had to ask for help to remind me how to do it from C, so I could call “Assembler” functions.

You can get C to do this using

#pragma linkage(IRRSPK00 ,OS)

Example

The syntax of the routine from the RACF callable services documentation is

CALL IRRSPK00 (Work_area,
  ALET, SAF_return_code,
  ALET, RACF_return_code,
  ALET, RACF_reason_code,
  ALET, Function_code,
  Option_word,
  Ticket_area,
  Ticket_options,
  Ticket_principal_userid,
  Application_Id
)

Here is part of my C program.

#pragma linkage(IRRSPK00 ,OS)
...
long SAF_RC,RACF_RC,RACF_RS; 
SAF_RC=0 ; 
long ALET = 0; 
// ticket options needs special treatment, see below
int Ticket_options = 1; 
int * pTO = & Ticket_options; 

rc=IRRSPK00( 
         &work_area, 
         &ALET , &SAF_RC, 
         &ALET , &RACF_RC, 
         &ALET , &RACF_RS, 
         &ALET ,&Function_code, 
         &Option_word, 
         &ticket, // length followed by area 
         &pTO, 
         &userid, 
         &appl 
         ); 

If you use #pragma linkage(IRRSPK00 ,OS) it sets on the high order bit. You pass the address of the parameters. I just used &variable, there are other ways.

Passing variables

Most of the parameters are passed by address for example &ALET inserts the address of the variable, conforming to the z/OS standards.

There is a field Ticket_principal_userid which is the name of a 10-byte area that consists of a 2-byte length field followed by the userid id for whom a PassTicket operation is to be performed followed by an 8-byte PassTicket field.

I defined a structures for each variable like

struct {
  short length;
  char value[8];
} ticket;

In the program I used &ticket.

Ticket option

The documentation says

Ticket_options: The name of a fullword containing the address of a binary bit string that identifies the ticket-specific processing to be performed.

It took me a while to understand what this meant. I had to use

int Ticket_options = 1; 
int * pTO = & Ticket_options; 

and use it

int Ticket_options = 1; 
int * pTO = & Ticket_options; 
...
 &ticket, // length followed by area 
 &pTO, 

Whoops R_GenSec (IRRSGS00 or IRRSGS64): Generic security API interface

I had great problems getting this to work. The documentation said

The address double words from 31 bit callers should have the first word filled with
zeros and the second word filled with the 31 bit address. Sub-parameter addresses will be in the format of the AMODE of the caller.

I do not know what this means. When I coded it as expected I got

CEE3250C The system or user abend S0E0 R=00000029

Which means invalid ALET supplied.

I converted the program to 64 bit and it still failed!