/*-------------------------------------------------------------------*/ int startall_cmd(int argc, char *argv[], char *cmdline) { int i; int rc = 0; CPU_BITMAP mask; UNREFERENCED(cmdline); if ( argc == 1 ) { OBTAIN_INTLOCK(NULL); mask = (~sysblk.started_mask) & sysblk.config_mask; for (i = 0; mask; i++) { if (mask & 1) { REGS *regs = sysblk.regs[i]; regs->opinterv = 0; regs->cpustate = CPUSTATE_STARTED; signal_condition(®s->intcond); } mask >>= 1; } RELEASE_INTLOCK(NULL); }
static void* con1052_panel_command (char *cmd) { DEVBLK *dev; char *input; int i; void* (*next_panel_command_handler)(char *cmd); for(dev = sysblk.firstdev; dev; dev = dev->nextdev) { if(dev->allocated && dev->hnd == &con1052_device_hndinfo && !strncasecmp(cmd,dev->filename,strlen(dev->filename)) ) { input = cmd + strlen(dev->filename); WRCMSG ("<pnl,color(lightyellow,black)>", HHC00008, "I", dev->filename, cmd+strlen(dev->filename) ); for(i = 0; i < dev->bufsize && input[i] != '\0'; i++) dev->buf[i] = isprint(input[i]) ? host_to_guest(input[i]) : SPACE; dev->keybdrem = dev->buflen = i; obtain_lock(&dev->lock); if(dev->iowaiters) { signal_condition(&dev->iocond); release_lock(&dev->lock); } else { release_lock(&dev->lock); device_attention (dev, CSW_ATTN); } return NULL; } } next_panel_command_handler = HDL_FINDNXT(con1052_panel_command); if (!next_panel_command_handler) return NULL; return next_panel_command_handler(cmd); }
void *http_server (void *arg) { int rc; /* Return code */ int lsock; /* Socket for listening */ int csock; /* Socket for conversation */ struct sockaddr_in server; /* Server address structure */ fd_set selset; /* Read bit map for select */ int optval; /* Argument for setsockopt */ TID httptid; /* Negotiation thread id */ struct timeval timeout; /* timeout value */ UNREFERENCED(arg); http_serv.httpshutdown = TRUE; hdl_adsc("http_shutdown",http_shutdown, NULL); /* Set root mode in order to set priority */ SETMODE(ROOT); /* Set server thread priority; ignore any errors */ if(setpriority(PRIO_PROCESS, 0, sysblk.srvprio)) WRMSG(HHC00136, "W", "setpriority()", strerror(errno)); /* Back to user mode */ SETMODE(USER); /* Display thread started message on control panel */ WRMSG (HHC00100, "I", (u_long)thread_id(), getpriority(PRIO_PROCESS,0), "HTTP server"); /* make sure root path is built */ if ( http_root() == NULL ) goto http_server_stop; /* Obtain a socket */ lsock = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP); if (lsock < 0) { WRMSG(HHC01800,"E", "socket()", strerror(HSO_errno)); goto http_server_stop; } /* Allow previous instance of socket to be reused */ optval = 1; setsockopt (lsock, SOL_SOCKET, SO_REUSEADDR, (void*)&optval, sizeof(optval)); /* Prepare the sockaddr structure for the bind */ memset (&server, 0, sizeof(server)); server.sin_family = AF_INET; server.sin_addr.s_addr = INADDR_ANY; server.sin_port = http_serv.httpport; server.sin_port = htons(server.sin_port); http_serv.httpbinddone = FALSE; /* Attempt to bind the socket to the port */ while (TRUE) { rc = bind (lsock, (struct sockaddr *)&server, sizeof(server)); if (rc == 0 || HSO_errno != HSO_EADDRINUSE) break; WRMSG(HHC01804, "W", http_serv.httpport); SLEEP(10); } /* end while */ if (rc != 0) { WRMSG(HHC01800,"E", "bind()", strerror(HSO_errno)); goto http_server_stop; } else http_serv.httpbinddone = TRUE; /* Put the socket into listening state */ rc = listen (lsock, 32); if (rc < 0) { WRMSG(HHC01800,"E", "listen()", strerror(HSO_errno)); http_serv.httpbinddone = FALSE; goto http_server_stop; } http_serv.httpshutdown = FALSE; WRMSG(HHC01803, "I", http_serv.httpport); /* Handle http requests */ while ( !http_serv.httpshutdown ) { /* Initialize the select parameters */ FD_ZERO (&selset); FD_SET (lsock, &selset); timeout.tv_sec = 0; timeout.tv_usec = 10000; /* until a better way to implement this use standard windows */ #undef select /* Wait for a file descriptor to become ready use NON-BLOCKING select()*/ rc = select ( lsock+1, &selset, NULL, NULL, &timeout ); if ( rc == 0 || http_serv.httpshutdown ) continue; if (rc < 0 ) { if (HSO_errno == HSO_EINTR) continue; WRMSG(HHC01800, "E", "select()", strerror(HSO_errno)); break; } /* If a http request has arrived then accept it */ if (FD_ISSET(lsock, &selset)) { /* Accept the connection and create conversation socket */ csock = accept (lsock, NULL, NULL); if (csock < 0) { WRMSG(HHC01800, "E", "accept()", strerror(HSO_errno)); continue; } /* Create a thread to execute the http request */ rc = create_thread (&httptid, DETACHED, http_request, (void *)(uintptr_t)csock, "http_request"); if(rc) { WRMSG(HHC00102, "E", strerror(rc)); close_socket (csock); } } /* end if(lsock) */ } /* end while */ /* Close the listening socket */ close_socket (lsock); http_server_stop: if ( !sysblk.shutdown ) hdl_rmsc(http_shutdown, NULL); /* Display thread started message on control panel */ WRMSG(HHC00101, "I", (u_long)thread_id(), getpriority(PRIO_PROCESS,0), "HTTP server"); sysblk.httptid = 0; http_serv.httpbinddone = FALSE; signal_condition(&http_serv.http_wait_shutdown); return NULL; } /* end function http_server */
SEXP cstop(SEXP condition) { return signal_condition(condition, "stop"); }
SEXP cwarn(SEXP condition) { return signal_condition(condition, "warning"); }
SEXP cmessage(SEXP condition) { return signal_condition(condition, "message"); }
static void* logger_thread(void *arg) { int bytes_read; UNREFERENCED(arg); /* Set root mode in order to set priority */ SETMODE(ROOT); /* Set device thread priority; ignore any errors */ if(set_thread_priority(0, sysblk.devprio)) WRMSG(HHC00136, "W", "set_thread_priority()", strerror(errno)); /* Back to user mode */ SETMODE(USER); #if !defined( _MSVC_ ) /* Redirect stdout to the logger */ if(dup2(logger_syslogfd[LOG_WRITE],STDOUT_FILENO) == -1) { if(logger_hrdcpy) fprintf(logger_hrdcpy, MSG(HHC02102, "E", "dup2()", strerror(errno))); exit(1); } #endif /* !defined( _MSVC_ ) */ setvbuf (stdout, NULL, _IONBF, 0); obtain_lock(&logger_lock); logger_active = 1; /* Signal initialization complete */ signal_condition(&logger_cond); release_lock(&logger_lock); /* ZZ FIXME: We must empty the read pipe before we terminate */ /* (Couldn't we just loop waiting for a 'select(,&readset,,,timeout)' to return zero?? Or use the 'poll' function similarly?? - Fish) */ while(logger_active) { bytes_read = read_pipe(logger_syslogfd[LOG_READ],logger_buffer + logger_currmsg, ((logger_bufsize - logger_currmsg) > LOG_DEFSIZE ? LOG_DEFSIZE : logger_bufsize - logger_currmsg)); if(bytes_read == -1) { int read_pipe_errno = HSO_errno; // (ignore any/all errors at shutdown) if (sysblk.shutdown) continue; if (HSO_EINTR == read_pipe_errno) continue; obtain_lock(&logger_lock); if(logger_hrdcpy) { fprintf(logger_hrdcpy, MSG(HHC02102, "E", "read_pipe()", strerror(read_pipe_errno))); } release_lock(&logger_lock); bytes_read = 0; } /* If Hercules is not running in daemon mode and panel initialization is not yet complete, write message to stderr so the user can see it on the terminal */ if (!sysblk.daemon_mode) { if (!sysblk.panel_init) { char* pLeft2 = logger_buffer + logger_currmsg; int nLeft2 = bytes_read; #if defined( OPTION_MSGCLR ) /* Remove "<pnl,..." color string if it exists */ if (1 && nLeft2 > 5 && strncasecmp( pLeft2, "<pnl", 4 ) == 0 && (pLeft2 = memchr( pLeft2+4, '>', nLeft2-4 )) != NULL ) { pLeft2++; nLeft2 -= (int)(pLeft2 - (logger_buffer + logger_currmsg)); } #endif // defined( OPTION_MSGCLR ) /* (ignore any errors; we did the best we could) */ if (nLeft2) { if ( fwrite( pLeft2, nLeft2, 1, stderr ) ) { perror(QLINE "fwrite failure/HHC02102 "); } } } } obtain_lock(&logger_lock); /* Write log data to hardcopy file */ if (logger_hrdcpy) { /* Need to prefix each line with a timestamp. */ static int needstamp = 1; char* pLeft = logger_buffer + logger_currmsg; int nLeft = bytes_read; char* pRight = NULL; int nRight = 0; char* pNL = NULL; /* (pointer to NEWLINE character) */ if (needstamp) { if (!sysblk.logoptnotime) logger_logfile_timestamp(); needstamp = 0; } while ( (pNL = memchr( pLeft, '\n', nLeft )) != NULL ) { pRight = pNL + 1; nRight = nLeft - (int)(pRight - pLeft); nLeft -= nRight; #if defined( OPTION_MSGCLR ) /* Remove "<pnl...>" color string if it exists */ { char* pLeft2 = pLeft; int nLeft2 = nLeft; if (1 && nLeft > 5 && strncasecmp( pLeft, "<pnl", 4 ) == 0 && (pLeft2 = memchr( pLeft+4, '>', nLeft-4 )) != NULL ) { pLeft2++; nLeft2 -= (int)(pLeft2 - pLeft); } else { pLeft2 = pLeft; nLeft2 = nLeft; } if (nLeft2) logger_logfile_write( pLeft2, nLeft2 ); } #else // !defined( OPTION_MSGCLR ) if (nLeft) logger_logfile_write( pLeft, nLeft ); #endif // defined( OPTION_MSGCLR ) pLeft = pRight; nLeft = nRight; if (!nLeft) { needstamp = 1; break; } if (!sysblk.logoptnotime) logger_logfile_timestamp(); } if (nLeft) logger_logfile_write( pLeft, nLeft ); } release_lock(&logger_lock); /* Increment buffer index to next available position */ logger_currmsg += bytes_read; if(logger_currmsg >= logger_bufsize) { logger_currmsg = 0; logger_wrapped = 1; } /* Notify all interested parties new log data is available */ obtain_lock(&logger_lock); broadcast_condition(&logger_cond); release_lock(&logger_lock); } logger_tid = 0; /* Logger is now terminating */ obtain_lock(&logger_lock); /* Write final message to hardcopy file */ if (logger_hrdcpy) { char* term_msg = MSG(HHC02103, "I"); size_t term_msg_len = strlen(term_msg); if (!sysblk.logoptnotime) logger_logfile_timestamp(); logger_logfile_write( term_msg, term_msg_len ); } /* Redirect all msgs to stderr */ logger_syslog[LOG_WRITE] = stderr; logger_syslogfd[LOG_WRITE] = STDERR_FILENO; fflush(stderr); /* Signal any waiting tasks */ broadcast_condition(&logger_cond); release_lock(&logger_lock); return NULL; }
DLL_EXPORT int ptt_cmd(int argc, char *argv[], char* cmdline) { int rc = 0; int n, to = -1; char c; UNREFERENCED(cmdline); if (argc > 1) { /* process arguments; last arg can be trace table size */ for (--argc, argv++; argc; --argc, ++argv) { if (strcasecmp("opts", argv[0]) == 0) continue; else if (strcasecmp("error", argv[0]) == 0) { pttclass |= PTT_CL_ERR; continue; } else if (strcasecmp("noerror", argv[0]) == 0) { pttclass &= ~PTT_CL_ERR; continue; } else if (strcasecmp("control", argv[0]) == 0) { pttclass |= PTT_CL_INF; continue; } else if (strcasecmp("nocontrol", argv[0]) == 0) { pttclass &= ~PTT_CL_INF; continue; } else if (strcasecmp("prog", argv[0]) == 0) { pttclass |= PTT_CL_PGM; continue; } else if (strcasecmp("noprog", argv[0]) == 0) { pttclass &= ~PTT_CL_PGM; continue; } else if (strcasecmp("inter", argv[0]) == 0) { pttclass |= PTT_CL_CSF; continue; } else if (strcasecmp("nointer", argv[0]) == 0) { pttclass &= ~PTT_CL_CSF; continue; } else if (strcasecmp("sie", argv[0]) == 0) { pttclass |= PTT_CL_SIE; continue; } else if (strcasecmp("nosie", argv[0]) == 0) { pttclass &= ~PTT_CL_SIE; continue; } else if (strcasecmp("signal", argv[0]) == 0) { pttclass |= PTT_CL_SIG; continue; } else if (strcasecmp("nosignal", argv[0]) == 0) { pttclass &= ~PTT_CL_SIG; continue; } else if (strcasecmp("io", argv[0]) == 0) { pttclass |= PTT_CL_IO; continue; } else if (strcasecmp("noio", argv[0]) == 0) { pttclass &= ~PTT_CL_IO; continue; } else if (strcasecmp("timer", argv[0]) == 0) { pttclass |= PTT_CL_TMR; continue; } else if (strcasecmp("notimer", argv[0]) == 0) { pttclass &= ~PTT_CL_TMR; continue; } else if (strcasecmp("logger", argv[0]) == 0) { pttclass |= PTT_CL_LOG; continue; } else if (strcasecmp("nologger", argv[0]) == 0) { pttclass &= ~PTT_CL_LOG; continue; } else if (strcasecmp("nothreads", argv[0]) == 0) { pttclass &= ~PTT_CL_THR; continue; } else if (strcasecmp("threads", argv[0]) == 0) { pttclass |= PTT_CL_THR; continue; } else if (strcasecmp("nolock", argv[0]) == 0) { pttnolock = 1; continue; } else if (strcasecmp("lock", argv[0]) == 0) { pttnolock = 0; continue; } else if (strcasecmp("notod", argv[0]) == 0) { pttnotod = 1; continue; } else if (strcasecmp("tod", argv[0]) == 0) { pttnotod = 0; continue; } else if (strcasecmp("nowrap", argv[0]) == 0) { pttnowrap = 1; continue; } else if (strcasecmp("wrap", argv[0]) == 0) { pttnowrap = 0; continue; } else if (strncasecmp("to=", argv[0], 3) == 0 && strlen(argv[0]) > 3 && (sscanf(&argv[0][3], "%d%c", &to, &c) == 1 && to >= 0)) { pttto = to; continue; } else if (argc == 1 && sscanf(argv[0], "%d%c", &n, &c) == 1 && n >= 0) { OBTAIN_PTTLOCK; if (pttracen == 0) { if (pttrace != NULL) { RELEASE_PTTLOCK; WRMSG(HHC90010, "E"); return -1; } } else if (pttrace) { pttracen = 0; RELEASE_PTTLOCK; usleep(1000); OBTAIN_PTTLOCK; free (pttrace); pttrace = NULL; } ptt_trace_init (n, 0); RELEASE_PTTLOCK; } else { WRMSG(HHC90011, "E", argv[0]); rc = -1; break; } } /* for each ptt argument */ /* wakeup timeout thread if to= specified */ if (to >= 0 && ptttotid) { obtain_lock (&ptttolock); ptttotid = 0; signal_condition (&ptttocond); release_lock (&ptttolock); } /* start timeout thread if positive to= specified */ if (to > 0) { obtain_lock (&ptttolock); ptttotid = 0; rc = create_thread (&ptttotid, NULL, ptt_timeout, NULL, "ptt_timeout"); if (rc) WRMSG(HHC00102, "E", strerror(rc)); release_lock (&ptttolock); } } else { if (pttracen) rc = ptt_pthread_print(); WRMSG(HHC90012, "I", (pttclass & PTT_CL_INF) ? "control " : "", (pttclass & PTT_CL_ERR) ? "error " : "", (pttclass & PTT_CL_PGM) ? "prog " : "", (pttclass & PTT_CL_CSF) ? "inter " : "", (pttclass & PTT_CL_SIE) ? "sie " : "", (pttclass & PTT_CL_SIG) ? "signal " : "", (pttclass & PTT_CL_IO) ? "io " : "", (pttclass & PTT_CL_TMR) ? "timer " : "", (pttclass & PTT_CL_THR) ? "threads " : "", (pttclass & PTT_CL_LOG) ? "logger " : "", pttnolock ? "nolock" : "lock", pttnotod ? "notod" : "tod", pttnowrap ? "nowrap" : "wrap", pttto, pttracen); } return rc; }
int suspend_cmd(int argc, char *argv[],char *cmdline) { char *fn = SR_DEFAULT_FILENAME; SR_FILE *file; CPU_BITMAP started_mask; struct timeval tv; time_t tt; int i, j, rc; REGS *regs; DEVBLK *dev; IOINT *ioq; BYTE psw[16]; UNREFERENCED(cmdline); if (argc > 2) { // "SR: too many arguments" WRMSG(HHC02000, "E"); return -1; } if (argc == 2) fn = argv[1]; file = SR_OPEN (fn, "wb"); if (file == NULL) { // "SR: error in function '%s': '%s'" WRMSG(HHC02001, "E","open()",strerror(errno)); return -1; } TRACE("SR: Begin Suspend Processing...\n"); /* Save CPU state and stop all CPU's */ TRACE("SR: Stopping All CPUs...\n"); OBTAIN_INTLOCK(NULL); started_mask = sysblk.started_mask; while (sysblk.started_mask) { for (i = 0; i < sysblk.maxcpu; i++) { if (IS_CPU_ONLINE(i)) { sysblk.regs[i]->cpustate = CPUSTATE_STOPPING; ON_IC_INTERRUPT(sysblk.regs[i]); signal_condition(&sysblk.regs[i]->intcond); } } RELEASE_INTLOCK(NULL); usleep (1000); OBTAIN_INTLOCK(NULL); } RELEASE_INTLOCK(NULL); /* Wait for I/O queue to clear out */ TRACE("SR: Waiting for I/O Queue to clear...\n"); #ifdef OPTION_FISHIO SLEEP (2); #else obtain_lock (&sysblk.ioqlock); while (sysblk.ioq) { release_lock (&sysblk.ioqlock); usleep (1000); obtain_lock (&sysblk.ioqlock); } release_lock (&sysblk.ioqlock); #endif /* Wait for active I/Os to complete */ TRACE("SR: Waiting for Active I/Os to Complete...\n"); for (i = 1; i < 5000; i++) { dev = sr_active_devices(); if (dev == NULL) break; if (i % 500 == 0) { // "SR: waiting for device %04X" WRMSG(HHC02002, "W", dev->devnum); } usleep (10000); } if (dev != NULL) { // "SR: device %04X still busy, proceeding anyway" WRMSG(HHC02003, "W",dev->devnum); } /* Write header */ TRACE("SR: Writing File Header...\n"); SR_WRITE_STRING(file, SR_HDR_ID, SR_ID); SR_WRITE_STRING(file, SR_HDR_VERSION, VERSION); gettimeofday(&tv, NULL); tt = tv.tv_sec; SR_WRITE_STRING(file, SR_HDR_DATE, ctime(&tt)); /* Write system data */ TRACE("SR: Saving System Data...\n"); SR_WRITE_STRING(file,SR_SYS_ARCH_NAME,arch_name[sysblk.arch_mode]); SR_WRITE_VALUE (file,SR_SYS_STARTED_MASK,started_mask,sizeof(started_mask)); SR_WRITE_VALUE (file,SR_SYS_MAINSIZE,sysblk.mainsize,sizeof(sysblk.mainsize)); TRACE("SR: Saving MAINSTOR...\n"); SR_WRITE_BUF (file,SR_SYS_MAINSTOR,sysblk.mainstor,sysblk.mainsize); SR_WRITE_VALUE (file,SR_SYS_SKEYSIZE,(sysblk.mainsize/STORAGE_KEY_UNITSIZE),sizeof(U32)); TRACE("SR: Saving Storage Keys...\n"); SR_WRITE_BUF (file,SR_SYS_STORKEYS,sysblk.storkeys,sysblk.mainsize/STORAGE_KEY_UNITSIZE); SR_WRITE_VALUE (file,SR_SYS_XPNDSIZE,sysblk.xpndsize,sizeof(sysblk.xpndsize)); TRACE("SR: Saving Expanded Storage...\n"); SR_WRITE_BUF (file,SR_SYS_XPNDSTOR,sysblk.xpndstor,4096*sysblk.xpndsize); SR_WRITE_VALUE (file,SR_SYS_CPUID,sysblk.cpuid,sizeof(sysblk.cpuid)); SR_WRITE_VALUE (file,SR_SYS_IPLDEV,sysblk.ipldev,sizeof(sysblk.ipldev)); SR_WRITE_VALUE (file,SR_SYS_IPLCPU,sysblk.iplcpu,sizeof(sysblk.iplcpu)); SR_WRITE_VALUE (file,SR_SYS_MBO,sysblk.mbo,sizeof(sysblk.mbo)); SR_WRITE_VALUE (file,SR_SYS_MBK,sysblk.mbk,sizeof(sysblk.mbk)); SR_WRITE_VALUE (file,SR_SYS_MBM,sysblk.mbm,sizeof(sysblk.mbm)); SR_WRITE_VALUE (file,SR_SYS_MBD,sysblk.mbd,sizeof(sysblk.mbd)); for (ioq = sysblk.iointq; ioq; ioq = ioq->next) if (ioq->pcipending) { SR_WRITE_VALUE(file,SR_SYS_PCIPENDING_LCSS, SSID_TO_LCSS(ioq->dev->ssid),sizeof(U16)); SR_WRITE_VALUE(file,SR_SYS_PCIPENDING, ioq->dev->devnum,sizeof(ioq->dev->devnum)); } else if (ioq->attnpending) { SR_WRITE_VALUE(file,SR_SYS_ATTNPENDING_LCSS, SSID_TO_LCSS(ioq->dev->ssid),sizeof(U16)); SR_WRITE_VALUE(file,SR_SYS_ATTNPENDING, ioq->dev->devnum,sizeof(ioq->dev->devnum)); } else { SR_WRITE_VALUE(file,SR_SYS_IOPENDING_LCSS, SSID_TO_LCSS(ioq->dev->ssid),sizeof(U16)); SR_WRITE_VALUE(file,SR_SYS_IOPENDING, ioq->dev->devnum,sizeof(ioq->dev->devnum)); } for (i = 0; i < 8; i++) SR_WRITE_VALUE(file,SR_SYS_CHP_RESET+i,sysblk.chp_reset[i],sizeof(sysblk.chp_reset[0])); SR_WRITE_VALUE (file,SR_SYS_SERVPARM,sysblk.servparm,sizeof(sysblk.servparm)); SR_WRITE_VALUE (file,SR_SYS_SIGINTREQ,sysblk.sigintreq,1); SR_WRITE_STRING(file,SR_SYS_LOADPARM,str_loadparm()); SR_WRITE_VALUE (file,SR_SYS_INTS_STATE,sysblk.ints_state,sizeof(sysblk.ints_state)); SR_WRITE_HDR(file, SR_DELIMITER, 0); /* Save service console state */ TRACE("SR: Saving Service Console State...\n"); SR_WRITE_HDR(file, SR_SYS_SERVC, 0); servc_hsuspend(file); SR_WRITE_HDR(file, SR_DELIMITER, 0); /* Save clock state */ TRACE("SR: Saving Clock State...\n"); SR_WRITE_HDR(file, SR_SYS_CLOCK, 0); clock_hsuspend(file); SR_WRITE_HDR(file, SR_DELIMITER, 0); /* Write CPU data */ for (i = 0; i < sysblk.maxcpu; i++) { if (!IS_CPU_ONLINE(i)) continue; TRACE("SR: Saving CPU %d Data...\n", i); regs = sysblk.regs[i]; SR_WRITE_VALUE(file, SR_CPU, i, sizeof(i)); SR_WRITE_VALUE(file, SR_CPU_ARCHMODE, regs->arch_mode,sizeof(regs->arch_mode)); SR_WRITE_VALUE(file, SR_CPU_PX, regs->PX_G,sizeof(regs->PX_G)); copy_psw (regs, psw); SR_WRITE_BUF(file, SR_CPU_PSW, psw, 16); for (j = 0; j < 16; j++) SR_WRITE_VALUE(file, SR_CPU_GR+j, regs->GR_G(j),sizeof(regs->GR_G(0))); for (j = 0; j < 16; j++) SR_WRITE_VALUE(file, SR_CPU_CR+j, regs->CR_G(j),sizeof(regs->CR_G(0))); for (j = 0; j < 16; j++) SR_WRITE_VALUE(file, SR_CPU_AR+j, regs->ar[j],sizeof(regs->ar[0])); for (j = 0; j < 32; j++) SR_WRITE_VALUE(file, SR_CPU_FPR+j, regs->fpr[j],sizeof(regs->fpr[0])); SR_WRITE_VALUE(file, SR_CPU_FPC, regs->fpc, sizeof(regs->fpc)); SR_WRITE_VALUE(file, SR_CPU_DXC, regs->dxc, sizeof(regs->dxc)); SR_WRITE_VALUE(file, SR_CPU_MC, regs->MC_G, sizeof(regs->MC_G)); SR_WRITE_VALUE(file, SR_CPU_EA, regs->EA_G, sizeof(regs->EA_G)); SR_WRITE_VALUE(file, SR_CPU_PTIMER, cpu_timer(regs), sizeof(S64)); SR_WRITE_VALUE(file, SR_CPU_CLKC, regs->clkc, sizeof(regs->clkc)); SR_WRITE_VALUE(file, SR_CPU_CHANSET, regs->chanset, sizeof(regs->chanset)); SR_WRITE_VALUE(file, SR_CPU_TODPR, regs->todpr, sizeof(regs->todpr)); SR_WRITE_VALUE(file, SR_CPU_MONCLASS, regs->monclass, sizeof(regs->monclass)); SR_WRITE_VALUE(file, SR_CPU_EXCARID, regs->excarid, sizeof(regs->excarid)); SR_WRITE_VALUE(file, SR_CPU_BEAR, regs->bear, sizeof(regs->bear)); SR_WRITE_VALUE(file, SR_CPU_OPNDRID, regs->opndrid, sizeof(regs->opndrid)); SR_WRITE_VALUE(file, SR_CPU_CHECKSTOP, regs->checkstop, 1); SR_WRITE_VALUE(file, SR_CPU_HOSTINT, regs->hostint, 1); SR_WRITE_VALUE(file, SR_CPU_EXECFLAG, regs->execflag, 1); // SR_WRITE_VALUE(file, SR_CPU_INSTVALID, regs->instvalid, 1); SR_WRITE_VALUE(file, SR_CPU_PERMODE, regs->permode, 1); SR_WRITE_VALUE(file, SR_CPU_LOADSTATE, regs->loadstate, 1); SR_WRITE_VALUE(file, SR_CPU_INVALIDATE, regs->invalidate, 1); SR_WRITE_VALUE(file, SR_CPU_SIGPRESET, regs->sigpreset, 1); SR_WRITE_VALUE(file, SR_CPU_SIGPIRESET, regs->sigpireset, 1); SR_WRITE_VALUE(file, SR_CPU_INTS_STATE, regs->ints_state, sizeof(regs->ints_state)); SR_WRITE_VALUE(file, SR_CPU_INTS_MASK, regs->ints_mask, sizeof(regs->ints_mask)); for (j = 0; j < sysblk.maxcpu; j++) SR_WRITE_VALUE(file, SR_CPU_MALFCPU+j, regs->malfcpu[j], sizeof(regs->malfcpu[0])); for (j = 0; j < sysblk.maxcpu; j++) SR_WRITE_VALUE(file, SR_CPU_EMERCPU+j, regs->emercpu[j], sizeof(regs->emercpu[0])); SR_WRITE_VALUE(file, SR_CPU_EXTCCPU, regs->extccpu, sizeof(regs->extccpu)); SR_WRITE_HDR(file, SR_DELIMITER, 0); } /* Write Device data */ for (dev = sysblk.firstdev; dev; dev = dev->nextdev) { if (!(dev->pmcw.flag5 & PMCW5_V)) continue; TRACE("SR: Saving Device %4.4X...\n", dev->devnum); /* These fields must come first so the device could be attached */ SR_WRITE_VALUE(file, SR_DEV, dev->devnum, sizeof(dev->devnum)); SR_WRITE_VALUE(file, SR_DEV_LCSS, SSID_TO_LCSS(dev->ssid), sizeof(U16)); SR_WRITE_VALUE(file, SR_DEV_ARGC, dev->argc, sizeof(dev->argc)); for (i = 0; i < dev->argc; i++) if (dev->argv[i]) { SR_WRITE_STRING(file, SR_DEV_ARGV, dev->argv[i]); } else { SR_WRITE_STRING(file, SR_DEV_ARGV, ""); } SR_WRITE_STRING(file, SR_DEV_TYPNAME, dev->typname); /* Common device fields */ SR_WRITE_BUF (file, SR_DEV_ORB, &dev->orb, sizeof(ORB)); SR_WRITE_BUF (file, SR_DEV_PMCW, &dev->pmcw, sizeof(PMCW)); SR_WRITE_BUF (file, SR_DEV_SCSW, &dev->scsw, sizeof(SCSW)); SR_WRITE_BUF (file, SR_DEV_PCISCSW, &dev->pciscsw, sizeof(SCSW)); SR_WRITE_BUF (file, SR_DEV_ATTNSCSW, &dev->attnscsw, sizeof(SCSW)); SR_WRITE_BUF (file, SR_DEV_CSW, dev->csw, 8); SR_WRITE_BUF (file, SR_DEV_PCICSW, dev->pcicsw, 8); SR_WRITE_BUF (file, SR_DEV_ATTNCSW, dev->attncsw, 8); SR_WRITE_BUF (file, SR_DEV_ESW, &dev->esw, sizeof(ESW)); SR_WRITE_BUF (file, SR_DEV_ECW, dev->ecw, 32); SR_WRITE_BUF (file, SR_DEV_SENSE, dev->sense, 32); SR_WRITE_VALUE(file, SR_DEV_PGSTAT, dev->pgstat, sizeof(dev->pgstat)); SR_WRITE_BUF (file, SR_DEV_PGID, dev->pgid, 11); /* By Adrian - SR_DEV_DRVPWD */ SR_WRITE_BUF (file, SR_DEV_DRVPWD, dev->drvpwd, 11); SR_WRITE_VALUE(file, SR_DEV_BUSY, dev->busy, 1); SR_WRITE_VALUE(file, SR_DEV_RESERVED, dev->reserved, 1); SR_WRITE_VALUE(file, SR_DEV_SUSPENDED, dev->suspended, 1); SR_WRITE_VALUE(file, SR_DEV_PCIPENDING, dev->pcipending, 1); SR_WRITE_VALUE(file, SR_DEV_ATTNPENDING, dev->attnpending, 1); SR_WRITE_VALUE(file, SR_DEV_PENDING, dev->pending, 1); SR_WRITE_VALUE(file, SR_DEV_STARTPENDING, dev->startpending, 1); SR_WRITE_VALUE(file, SR_DEV_CRWPENDING, dev->crwpending, 1); SR_WRITE_VALUE(file, SR_DEV_CCWADDR, dev->ccwaddr, sizeof(dev->ccwaddr)); SR_WRITE_VALUE(file, SR_DEV_IDAPMASK, dev->idapmask, sizeof(dev->idapmask)); SR_WRITE_VALUE(file, SR_DEV_IDAWFMT, dev->idawfmt, sizeof(dev->idawfmt)); SR_WRITE_VALUE(file, SR_DEV_CCWFMT, dev->ccwfmt, sizeof(dev->ccwfmt)); SR_WRITE_VALUE(file, SR_DEV_CCWKEY, dev->ccwkey, sizeof(dev->ccwkey)); /* Device type specific data */ SR_WRITE_VALUE(file, SR_DEV_DEVTYPE, dev->devtype, sizeof(dev->devtype)); if (dev->hnd->hsuspend) { rc = (dev->hnd->hsuspend) (dev, file); if (rc < 0) goto sr_error_exit; } SR_WRITE_HDR(file, SR_DELIMITER, 0); } TRACE("SR: Writing EOF\n"); SR_WRITE_HDR(file, SR_EOF, 0); SR_CLOSE (file); TRACE("SR: Suspend Complete; shutting down...\n"); /* Shutdown */ do_shutdown(); return 0; sr_error_exit: // "SR: error processing file '%s'" WRMSG(HHC02004, "E", fn); SR_CLOSE (file); return -1; }
// -------------------------------------------------------------------- // CTCI_EnqueueIPFrame // -------------------------------------------------------------------- // // Places the provided IP frame in the next available frame slot in // the adapter buffer. For details regarding the actual buffer layout // please refer to the comments preceding the CTCI_ReadThread function. // // Returns: // // 0 == Success // -1 == Failure; errno = ENOBUFS: No buffer space available // EMSGSIZE: Message too long // static int CTCI_EnqueueIPFrame( DEVBLK* pDEVBLK, BYTE* pData, size_t iSize ) { PCTCIHDR pFrame; PCTCISEG pSegment; PCTCBLK pCTCBLK = (PCTCBLK)pDEVBLK->dev_data; // Will frame NEVER fit into buffer?? if( iSize > MAX_CTCI_FRAME_SIZE( pCTCBLK ) ) { errno = EMSGSIZE; // Message too long return -1; // (-1==failure) } obtain_lock( &pCTCBLK->Lock ); // Ensure we dont overflow the buffer if( ( pCTCBLK->iFrameOffset + // Current buffer Offset sizeof( CTCIHDR ) + // Size of Block Header sizeof( CTCISEG ) + // Size of Segment Header iSize + // Size of Ethernet packet sizeof(pFrame->hwOffset) ) // Size of Block terminator > pCTCBLK->iMaxFrameBufferSize ) // Size of Frame buffer { release_lock( &pCTCBLK->Lock ); errno = ENOBUFS; // No buffer space available return -1; // (-1==failure) } // Fix-up Frame pointer pFrame = (PCTCIHDR)pCTCBLK->bFrameBuffer; // Fix-up Segment pointer pSegment = (PCTCISEG)( pCTCBLK->bFrameBuffer + sizeof( CTCIHDR ) + pCTCBLK->iFrameOffset ); // Initialize segment memset( pSegment, 0, iSize + sizeof( CTCISEG ) ); // Increment offset pCTCBLK->iFrameOffset += sizeof( CTCISEG ) + iSize; // Update next frame offset STORE_HW( pFrame->hwOffset, pCTCBLK->iFrameOffset + sizeof( CTCIHDR ) ); // Store segment length STORE_HW( pSegment->hwLength, sizeof( CTCISEG ) + iSize ); // Store Frame type STORE_HW( pSegment->hwType, ETH_TYPE_IP ); // Copy data memcpy( pSegment->bData, pData, iSize ); // Mark data pending pCTCBLK->fDataPending = 1; release_lock( &pCTCBLK->Lock ); obtain_lock( &pCTCBLK->EventLock ); signal_condition( &pCTCBLK->Event ); release_lock( &pCTCBLK->EventLock ); return 0; // (0==success) }