/*-------------------------------------------------------------------*/
static void* ARCH_DEP(scedio_thread)(void* arg)
{
SCCB_SCEDIOV_BK *scediov_bk;
SCCB_SCEDIOR_BK *scedior_bk;
SCCB_SCEDIO_BK *scedio_bk = (SCCB_SCEDIO_BK*) arg;
switch(scedio_bk->flag1) {
case SCCB_SCEDIO_FLG1_IOV:
scediov_bk = (SCCB_SCEDIOV_BK*)(scedio_bk + 1);
if( ARCH_DEP(scedio_iov)(scediov_bk) )
scedio_bk->flag3 |= SCCB_SCEDIO_FLG3_COMPLETE;
else
scedio_bk->flag3 &= ~SCCB_SCEDIO_FLG3_COMPLETE;
break;
case SCCB_SCEDIO_FLG1_IOR:
scedior_bk = (SCCB_SCEDIOR_BK*)(scedio_bk + 1);
if( ARCH_DEP(scedio_ior)(scedior_bk) )
scedio_bk->flag3 |= SCCB_SCEDIO_FLG3_COMPLETE;
else
scedio_bk->flag3 &= ~SCCB_SCEDIO_FLG3_COMPLETE;
break;
default:
PTT(PTT_CL_ERR,"*SERVC",(U32)scedio_bk->flag0,(U32)scedio_bk->flag1,scedio_bk->flag3);
}
OBTAIN_INTLOCK(NULL);
while(IS_IC_SERVSIG)
{
RELEASE_INTLOCK(NULL);
sched_yield();
OBTAIN_INTLOCK(NULL);
}
sclp_attention(SCCB_EVD_TYPE_SCEDIO);
scedio_tid = 0;
RELEASE_INTLOCK(NULL);
return NULL;
}
/*-------------------------------------------------------------------*/
static int ARCH_DEP(scedio_request)(U32 sclp_command, SCCB_EVD_HDR *evd_hdr)
{
SCCB_SCEDIO_BK *scedio_bk = (SCCB_SCEDIO_BK*)(evd_hdr + 1);
SCCB_SCEDIOV_BK *scediov_bk;
SCCB_SCEDIOR_BK *scedior_bk;
int rc;
static struct {
SCCB_SCEDIO_BK scedio_bk;
union {
SCCB_SCEDIOV_BK v;
SCCB_SCEDIOR_BK r;
} io;
} static_scedio_bk ;
static int scedio_pending;
if(sclp_command == SCLP_READ_EVENT_DATA)
{
int pending_req = scedio_pending;
U16 evd_len;
/* Return no data if the scedio thread is still active */
if(scedio_tid)
return 0;
/* Update the scedio_bk copy in the SCCB */
if(scedio_pending)
{
/* Zero all fields */
memset (evd_hdr, 0, sizeof(SCCB_EVD_HDR));
/* Set type in event header */
evd_hdr->type = SCCB_EVD_TYPE_SCEDIO;
/* Store scedio header */
*scedio_bk = static_scedio_bk.scedio_bk;
/* Calculate event response length */
evd_len = sizeof(SCCB_EVD_HDR) + sizeof(SCCB_SCEDIO_BK);
switch(scedio_bk->flag1) {
case SCCB_SCEDIO_FLG1_IOR:
scedior_bk = (SCCB_SCEDIOR_BK*)(scedio_bk + 1);
*scedior_bk = static_scedio_bk.io.r;
evd_len += sizeof(SCCB_SCEDIOR_BK);
break;
case SCCB_SCEDIO_FLG1_IOV:
scediov_bk = (SCCB_SCEDIOV_BK*)(scedio_bk + 1);
*scediov_bk = static_scedio_bk.io.v ;
evd_len += sizeof(SCCB_SCEDIOV_BK);
break;
default:
PTT(PTT_CL_ERR,"*SERVC",(U32)evd_hdr->type,(U32)scedio_bk->flag1,scedio_bk->flag3);
}
/* Set length in event header */
STORE_HW(evd_hdr->totlen, evd_len);
}
/* Reset the pending flag */
scedio_pending = 0;
/* Return true if a request was pending */
return pending_req;
}
else
{
#if !defined(NO_SIGABEND_HANDLER)
switch(scedio_bk->flag1) {
case SCCB_SCEDIO_FLG1_IOV:
scediov_bk = (SCCB_SCEDIOV_BK*)(scedio_bk + 1);
switch(scediov_bk->type) {
case SCCB_SCEDIOV_TYPE_INIT:
/* Kill the scedio thread if it is active */
if( scedio_tid )
{
OBTAIN_INTLOCK(NULL);
signal_thread(scedio_tid, SIGKILL);
scedio_tid = 0;
scedio_pending = 0;
RELEASE_INTLOCK(NULL);
}
break;
}
break;
}
#endif
/* Take a copy of the scedio_bk in the SCCB */
static_scedio_bk.scedio_bk = *scedio_bk;
switch(scedio_bk->flag1) {
case SCCB_SCEDIO_FLG1_IOR:
scedior_bk = (SCCB_SCEDIOR_BK*)(scedio_bk + 1);
static_scedio_bk.io.r = *scedior_bk;
break;
case SCCB_SCEDIO_FLG1_IOV:
scediov_bk = (SCCB_SCEDIOV_BK*)(scedio_bk + 1);
static_scedio_bk.io.v = *scediov_bk;
break;
default:
PTT(PTT_CL_ERR,"*SERVC",(U32)evd_hdr->type,(U32)scedio_bk->flag1,scedio_bk->flag3);
}
/* Create the scedio thread */
rc = create_thread(&scedio_tid, &sysblk.detattr,
ARCH_DEP(scedio_thread), &static_scedio_bk, "scedio_thread");
if (rc)
{
WRMSG(HHC00102, "E", strerror(rc));
return -1;
}
scedio_pending = 1;
}
return 0;
}
static int ARCH_DEP(scedio_iov)(SCCB_SCEDIOV_BK *scediov_bk)
{
S64 seek;
S64 length;
S64 totread, totwrite;
U64 sto;
char fname[MAX_PATH];
switch(scediov_bk->type) {
case SCCB_SCEDIOV_TYPE_INIT:
return TRUE;
break;
case SCCB_SCEDIOV_TYPE_READ:
/* Ensure file access is allowed and within specified directory */
if(!check_sce_filepath((char*)scediov_bk->filename,fname))
{
if(errno != ENOENT)
WRMSG (HHC00605, "E", fname, strerror(errno));
return FALSE;
}
FETCH_DW(sto,scediov_bk->sto);
FETCH_DW(seek,scediov_bk->seek);
FETCH_DW(length,scediov_bk->length);
totread = ARCH_DEP(read_file)(fname, sto, seek, length);
if(totread > 0)
{
STORE_DW(scediov_bk->length,totread);
if(totread == length)
STORE_DW(scediov_bk->ncomp,0);
else
STORE_DW(scediov_bk->ncomp,seek+totread);
return TRUE;
}
else
return FALSE;
break;
case SCCB_SCEDIOV_TYPE_CREATE:
case SCCB_SCEDIOV_TYPE_APPEND:
/* Ensure file access is allowed and within specified directory */
if(!check_sce_filepath((char*)scediov_bk->filename,fname))
{
if(errno != ENOENT)
WRMSG (HHC00605, "E", fname, strerror(errno));
/* A file not found error may be expected for a create request */
if(!(errno == ENOENT && scediov_bk->type == SCCB_SCEDIOV_TYPE_CREATE))
return FALSE;
}
FETCH_DW(sto,scediov_bk->sto);
FETCH_DW(length,scediov_bk->length);
totwrite = ARCH_DEP(write_file)(fname,
((scediov_bk->type == SCCB_SCEDIOV_TYPE_CREATE) ? (O_CREAT|O_TRUNC) : O_APPEND), sto, length);
if(totwrite >= 0)
{
STORE_DW(scediov_bk->ncomp,totwrite);
return TRUE;
}
else
return FALSE;
break;
default:
PTT(PTT_CL_ERR,"*SERVC",(U32)scediov_bk->type,(U32)scediov_bk->flag1,scediov_bk->flag2);
return FALSE;
}
}
/*-------------------------------------------------------------------*/
void ARCH_DEP(diag204_call) (int r1, int r2, REGS *regs)
{
DIAG204_HDR *hdrinfo; /* Header */
DIAG204_PART *partinfo; /* Partition info */
DIAG204_PART_CPU *cpuinfo; /* CPU info */
#if defined(FEATURE_EXTENDED_DIAG204)
DIAG204_X_HDR *hdrxinfo; /* Header */
DIAG204_X_PART *partxinfo; /* Partition info */
DIAG204_X_PART_CPU *cpuxinfo; /* CPU info */
U64 tdis;
#endif /*defined(FEATURE_EXTENDED_DIAG204)*/
RADR abs; /* abs addr of data area */
U64 dreg; /* work doubleword */
int i; /* loop counter */
struct rusage usage; /* RMF type data */
static U64 diag204tod; /* last diag204 tod */
#if defined(FEATURE_PHYSICAL_DIAG204)
static BYTE physical[8] =
{0xD7,0xC8,0xE8,0xE2,0xC9,0xC3,0xC1,0xD3}; /* PHYSICAL */
#endif /*defined(FEATURE_PHYSICAL_DIAG204)*/
/* Test DIAG204 command word */
switch (regs->GR_L(r2)) {
case 0x04:
abs = APPLY_PREFIXING (GR_A(r1,regs), regs->PX);
/* Program check if RMF data is not on a page boundary */
if ( (abs & PAGEFRAME_BYTEMASK) != 0x000)
ARCH_DEP(program_interrupt) (regs, PGM_SPECIFICATION_EXCEPTION);
/* Program check if RMF data area is outside main storage */
if ( abs > regs->mainlim )
ARCH_DEP(program_interrupt) (regs, PGM_ADDRESSING_EXCEPTION);
/* Point to DIAG 204 data area */
hdrinfo = (DIAG204_HDR*)(regs->mainstor + abs);
/* Mark page referenced */
STORAGE_KEY(abs, regs) |= STORKEY_REF | STORKEY_CHANGE;
/* save last diag204 tod */
dreg = diag204tod;
/* Retrieve the TOD clock value and shift out the epoch */
diag204tod = tod_clock(regs) << 8;
memset(hdrinfo, 0, sizeof(DIAG204_HDR));
hdrinfo->numpart = 1;
#if defined(FEATURE_PHYSICAL_DIAG204)
hdrinfo->flags = DIAG204_PHYSICAL_PRESENT;
#endif /*defined(FEATURE_PHYSICAL_DIAG204)*/
STORE_HW(hdrinfo->physcpu,sysblk.cpus);
STORE_HW(hdrinfo->offown,sizeof(DIAG204_HDR));
STORE_DW(hdrinfo->diagstck,dreg);
/* hercules partition */
partinfo = (DIAG204_PART*)(hdrinfo + 1);
memset(partinfo, 0, sizeof(DIAG204_PART));
partinfo->partnum = 1; /* Hercules partition */
partinfo->virtcpu = sysblk.cpus;
get_lparname(partinfo->partname);
/* hercules cpu's */
getrusage(RUSAGE_SELF,&usage);
cpuinfo = (DIAG204_PART_CPU*)(partinfo + 1);
for(i = 0; i < sysblk.maxcpu; i++)
if (IS_CPU_ONLINE(i))
{
memset(cpuinfo, 0, sizeof(DIAG204_PART_CPU));
STORE_HW(cpuinfo->cpaddr,sysblk.regs[i]->cpuad);
cpuinfo->index=sysblk.ptyp[i];
STORE_HW(cpuinfo->weight,100);
dreg = (U64)(usage.ru_utime.tv_sec + usage.ru_stime.tv_sec) * 1000000;
dreg = (dreg + (usage.ru_utime.tv_usec + usage.ru_stime.tv_usec)) / sysblk.cpus;
dreg <<= 12;
STORE_DW(cpuinfo->totdispatch,dreg);
dreg = (U64)(usage.ru_utime.tv_sec)* 1000000;
dreg = (dreg + (usage.ru_utime.tv_usec)) / sysblk.cpus;
dreg <<= 12;
STORE_DW(cpuinfo->effdispatch,dreg);
cpuinfo += 1;
}
#if defined(FEATURE_PHYSICAL_DIAG204)
/* lpar management */
getrusage(RUSAGE_CHILDREN,&usage);
partinfo = (DIAG204_PART*)cpuinfo;
memset(partinfo, 0, sizeof(DIAG204_PART));
partinfo->partnum = 0; /* Physical machine */
partinfo->virtcpu = sysblk.cpus;
memcpy(partinfo->partname,physical,sizeof(physical));
/* report all emulated physical cpu's */
getrusage(RUSAGE_SELF,&usage);
cpuinfo = (DIAG204_PART_CPU*)(partinfo + 1);
for(i = 0; i < sysblk.maxcpu; i++)
if (IS_CPU_ONLINE(i))
{
memset(cpuinfo, 0, sizeof(DIAG204_PART_CPU));
STORE_HW(cpuinfo->cpaddr,sysblk.regs[i]->cpuad);
cpuinfo->index = sysblk.ptyp[i];
STORE_HW(cpuinfo->weight,100);
dreg = (U64)(usage.ru_utime.tv_sec + usage.ru_stime.tv_sec) * 1000000;
dreg = (dreg + (usage.ru_utime.tv_usec + usage.ru_stime.tv_usec)) / sysblk.cpus;
dreg <<= 12;
STORE_DW(cpuinfo->totdispatch,dreg);
dreg = (U64)(usage.ru_utime.tv_sec) * 1000000;
dreg = (dreg + (usage.ru_utime.tv_usec)) / sysblk.cpus;
dreg <<= 12;
STORE_DW(cpuinfo->effdispatch,dreg);
cpuinfo += 1;
}
#endif /*defined(FEATURE_PHYSICAL_DIAG204)*/
regs->GR_L(r2) = 0;
break;
#if defined(FEATURE_EXTENDED_DIAG204)
/* Extended subcode 5 returns the size of the data areas provided by extended subcodes 6 and 7 */
case 0x00010005:
i = sizeof(DIAG204_X_HDR) + ((sizeof(DIAG204_X_PART) + (sysblk.maxcpu * sizeof(DIAG204_X_PART_CPU))) * 2);
regs->GR_L(r2+1) = (i + PAGEFRAME_BYTEMASK) / PAGEFRAME_PAGESIZE;
regs->GR_L(r2) = 0;
break;
/* Provide extended information */
case 0x00010006:
/* We fall through as we do not have any secondary cpus (that we know of) */
/* Provide extended information, including information about secondary CPUs */
case 0x00010007:
/* Program check if RMF data is not on a page boundary */
if ( (regs->GR_L(r1) & PAGEFRAME_BYTEMASK) != 0x000)
ARCH_DEP(program_interrupt) (regs, PGM_SPECIFICATION_EXCEPTION);
/* Obtain absolute address of main storage block,
check protection, and set reference and change bits */
hdrxinfo = (DIAG204_X_HDR*)MADDR (GR_A(r1,regs), r1, regs, ACCTYPE_WRITE, regs->psw.pkey);
/* save last diag204 tod */
dreg = diag204tod;
/* Retrieve the TOD clock value and shift out the epoch */
diag204tod = tod_clock(regs) << 8;
memset(hdrxinfo, 0, sizeof(DIAG204_X_HDR));
hdrxinfo->numpart = 1;
#if defined(FEATURE_PHYSICAL_DIAG204)
hdrxinfo->flags = DIAG204_X_PHYSICAL_PRESENT;
#endif /*defined(FEATURE_PHYSICAL_DIAG204)*/
STORE_HW(hdrxinfo->physcpu,sysblk.cpus);
STORE_HW(hdrxinfo->offown,sizeof(DIAG204_X_HDR));
STORE_DW(hdrxinfo->diagstck1,(dreg >> 8));
STORE_DW(hdrxinfo->diagstck2,( 0x0000000001000000ULL | (regs->cpuad << 16) | regs->todpr));
/* hercules partition */
partxinfo = (DIAG204_X_PART*)(hdrxinfo + 1);
memset(partxinfo, 0, sizeof(DIAG204_PART));
partxinfo->partnum = 1; /* Hercules partition */
partxinfo->virtcpu = sysblk.cpus;
get_lparname(partxinfo->partname);
get_sysname(partxinfo->cpcname);
get_systype(partxinfo->osname);
STORE_DW(partxinfo->cssize,sysblk.mainsize);
STORE_DW(partxinfo->essize,sysblk.xpndsize);
get_sysplex(partxinfo->gr_name);
/* hercules cpu's */
getrusage(RUSAGE_SELF,&usage);
cpuxinfo = (DIAG204_X_PART_CPU*)(partxinfo + 1);
for(i = 0; i < sysblk.maxcpu; i++)
if (IS_CPU_ONLINE(i))
{
memset(cpuxinfo, 0, sizeof(DIAG204_X_PART_CPU));
STORE_HW(cpuxinfo->cpaddr,sysblk.regs[i]->cpuad);
cpuxinfo->index = sysblk.ptyp[i];
STORE_HW(cpuxinfo->weight,100);
tdis = (U64)(usage.ru_utime.tv_sec + usage.ru_stime.tv_sec) * 1000000;
tdis = (tdis + (usage.ru_utime.tv_usec + usage.ru_stime.tv_usec)) / sysblk.cpus;
tdis <<= 12;
STORE_DW(cpuxinfo->totdispatch,tdis);
dreg = (U64)(usage.ru_utime.tv_sec)* 1000000;
dreg = (dreg + (usage.ru_utime.tv_usec)) / sysblk.cpus;
dreg <<= 12;
STORE_DW(cpuxinfo->effdispatch,dreg);
STORE_HW(cpuxinfo->minweight,1000);
STORE_HW(cpuxinfo->curweight,1000);
STORE_HW(cpuxinfo->maxweight,1000);
STORE_DW(cpuxinfo->onlinetime, diag204tod - sysblk.todstart);
STORE_DW(cpuxinfo->waittime, (diag204tod - sysblk.todstart) - tdis);
STORE_HW(cpuxinfo->pmaweight,1000);
STORE_HW(cpuxinfo->polarweight,1000);
cpuxinfo += 1;
}
#if defined(FEATURE_PHYSICAL_DIAG204)
/* lpar management */
partxinfo = (DIAG204_X_PART*)cpuxinfo;
memset(partxinfo, 0, sizeof(DIAG204_X_PART));
partxinfo->partnum = 0; /* Physical machine */
partxinfo->virtcpu = sysblk.cpus;
memcpy(partxinfo->partname,physical,sizeof(physical));
/* report all emulated physical cpu's */
getrusage(RUSAGE_CHILDREN,&usage);
cpuxinfo = (DIAG204_PART_CPU*)(partinfo + 1);
for(i = 0; i < sysblk.maxcpu; i++)
if (IS_CPU_ONLINE(i))
{
memset(cpuxinfo, 0, sizeof(DIAG204_X_PART_CPU));
STORE_HW(cpuxinfo->cpaddr,sysblk.regs[i]->cpuad);
cpuxinfo->index = sysblk.ptyp[i];
STORE_HW(cpuxinfo->weight,100);
tdis = (U64)(usage.ru_utime.tv_sec + usage.ru_stime.tv_sec) * 1000000;
tdis = (tdis + (usage.ru_utime.tv_usec + usage.ru_stime.tv_usec)) / sysblk.cpus;
tdis <<= 12;
STORE_DW(cpuxinfo->totdispatch,tdis);
dreg = (U64)(usage.ru_utime.tv_sec)* 1000000;
dreg = (dreg + (usage.ru_utime.tv_usec)) / sysblk.cpus;
dreg <<= 12;
STORE_DW(cpuxinfo->effdispatch,dreg);
STORE_HW(cpuxinfo->minweight,1000);
STORE_HW(cpuxinfo->curweight,1000);
STORE_HW(cpuxinfo->maxweight,1000);
STORE_DW(cpuxinfo->onlinetime, diag204tod - sysblk.todstart);
STORE_DW(cpuxinfo->waittime, (diag204tod - sysblk.todstart) - tdis);
STORE_HW(cpuxinfo->pmaweight,1000);
STORE_HW(cpuxinfo->polarweight,1000);
cpuxinfo += 1;
}
#endif /*defined(FEATURE_PHYSICAL_DIAG204)*/
regs->GR_L(r2) = 0;
break;
#endif /*defined(FEATURE_EXTENDED_DIAG204)*/
default:
PTT(PTT_CL_ERR,"*DIAG204",regs->GR_L(r1),regs->GR_L(r2),regs->psw.IA_L);
regs->GR_L(r2) = 4;
} /*switch(regs->GR_L(r2))*/
} /* end function diag204_call */
/*-------------------------------------------------------------------*/
int ARCH_DEP(mssf_call) (int r1, int r2, REGS *regs)
{
U32 spccb_absolute_addr; /* Absolute addr of SPCCB */
U32 mssf_command; /* MSSF command word */
U32 spccblen; /* Length of SPCCB */
SPCCB_HEADER *spccb; /* -> SPCCB header */
SPCCB_CONFIG_INFO *spccbconfig; /* -> SPCCB CONFIG info */
SPCCB_CPU_INFO *spccbcpu; /* -> SPCCB CPU information */
SPCCB_CHP_STATUS *spccbchp; /* -> SPCCB channel path info */
U16 offset; /* Offset from start of SPCCB */
int i; /* loop counter */
DEVBLK *dev; /* Device block pointer */
/* R1 contains the real address of the SPCCB */
spccb_absolute_addr = APPLY_PREFIXING (regs->GR_L(r1), regs->PX);
/* R2 contains the service-processor-command word */
mssf_command = regs->GR_L(r2);
/* Program check if SPCCB is not on a doubleword boundary */
if ( spccb_absolute_addr & 0x00000007 )
ARCH_DEP(program_interrupt) (regs, PGM_SPECIFICATION_EXCEPTION);
/* Program check if SPCCB is outside main storage */
if ( spccb_absolute_addr > regs->mainlim )
ARCH_DEP(program_interrupt) (regs, PGM_ADDRESSING_EXCEPTION);
// /*debug*/logmsg("MSSF call %8.8X SPCCB=%8.8X\n",
// /*debug*/ mssf_command, spccb_absolute_addr);
/* Point to Service Processor Command Control Block */
spccb = (SPCCB_HEADER*)(regs->mainstor + spccb_absolute_addr);
/* Load SPCCB length from header */
FETCH_HW(spccblen,spccb->length);
/* Mark page referenced */
STORAGE_KEY(spccb_absolute_addr, regs) |= STORKEY_REF;
/* Program check if end of SPCCB falls outside main storage */
if ( sysblk.mainsize - spccblen < spccb_absolute_addr )
ARCH_DEP(program_interrupt) (regs, PGM_ADDRESSING_EXCEPTION);
/* Obtain the interrupt lock */
OBTAIN_INTLOCK(regs);
/* If a service signal is pending then we cannot process the request */
if( IS_IC_SERVSIG && (sysblk.servparm & SERVSIG_ADDR)) {
RELEASE_INTLOCK(regs);
return 2; /* Service Processor Busy */
}
if( spccb_absolute_addr & 0x7ffff800 ) {
spccb->resp[0] = SPCCB_REAS_NOT2KALIGN;
spccb->resp[1] = SPCCB_RESP_NOT2KALIGN;
} else
/* Test MSSF command word */
switch (mssf_command) {
case MSSF_READ_CONFIG_INFO:
/* Set response code X'01F0' if SPCCB length
is insufficient to contain CONFIG info */
if ( spccblen < 64 )
{
spccb->resp[0] = SPCCB_REAS_BADLENGTH;
spccb->resp[1] = SPCCB_RESP_BADLENGTH;
break;
}
/* Point to SPCCB data area following SPCCB header */
spccbconfig = (SPCCB_CONFIG_INFO*)(spccb+1);
memset (spccbconfig, 0, sizeof(SPCCB_CONFIG_INFO));
/* Set main storage size in SPCCB */
spccbconfig->totstori = sysblk.mainsize >> 20;
spccbconfig->storisiz = 1;
spccbconfig->hex04 = 0x04;
spccbconfig->hex01 = 0x01;
/* Set CPU array count and offset in SPCCB */
STORE_HW(spccbconfig->toticpu,sysblk.maxcpu);
offset = sizeof(SPCCB_HEADER) + sizeof(SPCCB_CONFIG_INFO);
STORE_HW(spccbconfig->officpu,offset);
/* Set HSA array count and offset in SPCCB */
STORE_HW(spccbconfig->tothsa,0);
offset += (U16)(sizeof(SPCCB_CPU_INFO) * sysblk.maxcpu);
STORE_HW(spccbconfig->offhsa,offset);
/* Move IPL load parameter to SPCCB */
get_loadparm (spccbconfig->loadparm);
/* Build the CPU information array after the SCP info */
spccbcpu = (SPCCB_CPU_INFO*)(spccbconfig+1);
for (i = 0; i < sysblk.maxcpu; i++, spccbcpu++)
{
memset( spccbcpu, 0, sizeof(SPCCB_CPU_INFO) );
spccbcpu->cpuaddr = i;
spccbcpu->todid = 0;
}
/* Set response code X'0010' in SPCCB header */
spccb->resp[0] = SPCCB_REAS_COMPLETE;
spccb->resp[1] = SPCCB_RESP_COMPLETE;
break;
case MSSF_READ_CHP_STATUS:
/* Set response code X'0300' if SPCCB length
is insufficient to contain channel path info */
if ( spccblen < sizeof(SPCCB_HEADER) + sizeof(SPCCB_CHP_STATUS))
{
spccb->resp[0] = SPCCB_REAS_BADLENGTH;
spccb->resp[1] = SPCCB_RESP_BADLENGTH;
break;
}
/* Point to SPCCB data area following SPCCB header */
spccbchp = (SPCCB_CHP_STATUS*)(spccb+1);
memset( spccbchp, 0, sizeof(SPCCB_CHP_STATUS) );
/* Identify CHPIDs used */
for (dev = sysblk.firstdev; dev != NULL; dev = dev->nextdev)
{
for (i = 0; i < 8; i++)
{
if( ((0x80 >> i) & dev->pmcw.pim) )
{
BYTE chpid;
chpid = dev->pmcw.chpid[i];
spccbchp->installed[chpid / 8] |= 0x80 >> (chpid % 8);
spccbchp->assigned[chpid / 8] |= 0x80 >> (chpid % 8);
spccbchp->configured[chpid / 8] |= 0x80 >> (chpid % 8);
}
}
}
/* Set response code X'0010' in SPCCB header */
spccb->resp[0] = SPCCB_REAS_COMPLETE;
spccb->resp[1] = SPCCB_RESP_COMPLETE;
break;
default:
PTT(PTT_CL_ERR,"*DIAG080",regs->GR_L(r1),regs->GR_L(r2),regs->psw.IA_L);
/* Set response code X'06F0' for invalid MSSF command */
spccb->resp[0] = SPCCB_REAS_UNASSIGNED;
spccb->resp[1] = SPCCB_RESP_UNASSIGNED;
break;
} /* end switch(mssf_command) */
/* Mark page changed */
STORAGE_KEY(spccb_absolute_addr, regs) |= STORKEY_CHANGE;
/* Set service signal external interrupt pending */
sysblk.servparm &= ~SERVSIG_ADDR;
sysblk.servparm |= spccb_absolute_addr;
ON_IC_SERVSIG;
/* Release the interrupt lock */
RELEASE_INTLOCK(regs);
/* Return condition code 0: Command initiated */
return 0;
} /* end function mssf_call */
/*-------------------------------------------------------------------*/
static void ARCH_DEP(external_interrupt) (int code, REGS *regs)
{
RADR pfx;
PSA *psa;
int rc;
PTT(PTT_CL_SIG,"*EXTINT",code,regs->cpuad,regs->psw.IA_L);
#if defined(_FEATURE_SIE)
/* Set the main storage reference and change bits */
if(SIE_MODE(regs)
#if defined(_FEATURE_EXPEDITED_SIE_SUBSET)
&& !SIE_FEATB(regs, S, EXP_TIMER)
#endif /*defined(_FEATURE_EXPEDITED_SIE_SUBSET)*/
#if defined(_FEATURE_EXTERNAL_INTERRUPT_ASSIST)
&& !SIE_FEATB(regs, EC0, EXTA)
#endif
)
{
/* Point to SIE copy of PSA in state descriptor */
psa = (void*)(regs->hostregs->mainstor + SIE_STATE(regs) + SIE_IP_PSA_OFFSET);
STORAGE_KEY(SIE_STATE(regs), regs->hostregs) |= (STORKEY_REF | STORKEY_CHANGE);
}
else
#endif /*defined(_FEATURE_SIE)*/
{
/* Point to PSA in main storage */
pfx = regs->PX;
#if defined(_FEATURE_EXPEDITED_SIE_SUBSET)
SIE_TRANSLATE(&pfx, ACCTYPE_SIE, regs);
#endif /*defined(_FEATURE_EXPEDITED_SIE_SUBSET)*/
psa = (void*)(regs->mainstor + pfx);
STORAGE_KEY(pfx, regs) |= (STORKEY_REF | STORKEY_CHANGE);
}
/* Store the interrupt code in the PSW */
regs->psw.intcode = code;
/* Zero extcpuad field unless extcall or ems signal or blockio */
if(code != EXT_EXTERNAL_CALL_INTERRUPT
#if defined(FEATURE_VM_BLOCKIO)
&& code != EXT_BLOCKIO_INTERRUPT
#endif /* defined(FEATURE_VM_BLOCKIO) */
&& code != EXT_EMERGENCY_SIGNAL_INTERRUPT)
STORE_HW(psa->extcpad,0);
#if defined(FEATURE_BCMODE)
/* For ECMODE, store external interrupt code at PSA+X'86' */
if ( ECMODE(®s->psw) )
#endif /*defined(FEATURE_BCMODE)*/
STORE_HW(psa->extint,code);
if ( !SIE_MODE(regs)
#if defined(_FEATURE_EXPEDITED_SIE_SUBSET)
|| SIE_FEATB(regs, S, EXP_TIMER)
#endif /*defined(_FEATURE_EXPEDITED_SIE_SUBSET)*/
#if defined(_FEATURE_EXTERNAL_INTERRUPT_ASSIST)
|| SIE_FEATB(regs, EC0, EXTA)
#endif
)
{
/* Store current PSW at PSA+X'18' */
ARCH_DEP(store_psw) (regs, psa->extold);
/* Load new PSW from PSA+X'58' */
rc = ARCH_DEP(load_psw) (regs, psa->extnew);
if ( rc )
{
RELEASE_INTLOCK(regs);
ARCH_DEP(program_interrupt)(regs, rc);
}
}
#if defined(FEATURE_INTERVAL_TIMER)
/* Ensure the interval timer is uptodate */
ARCH_DEP(store_int_timer_nolock) (regs);
#endif
RELEASE_INTLOCK(regs);
if ( SIE_MODE(regs)
#if defined(_FEATURE_EXPEDITED_SIE_SUBSET)
&& !SIE_FEATB(regs, S, EXP_TIMER)
#endif /*defined(_FEATURE_EXPEDITED_SIE_SUBSET)*/
#if defined(_FEATURE_EXTERNAL_INTERRUPT_ASSIST)
&& !SIE_FEATB(regs, EC0, EXTA)
#endif
)
longjmp (regs->progjmp, SIE_INTERCEPT_EXT);
else
longjmp (regs->progjmp, SIE_NO_INTERCEPT);
} /* end function external_interrupt */
