// This must be the first module to be initialized!
void systemInit(void)
{
if(isInit)
return;
canStartMutex = xSemaphoreCreateMutex();
xSemaphoreTake(canStartMutex, portMAX_DELAY);
usblinkInit();
sysLoadInit();
/* Initialized hear and early so that DEBUG_PRINT (buffered) can be used early */
crtpInit();
consoleInit();
DEBUG_PRINT("----------------------------\n");
DEBUG_PRINT(P_NAME " is up and running!\n");
DEBUG_PRINT("Build %s:%s (%s) %s\n", V_SLOCAL_REVISION,
V_SREVISION, V_STAG, (V_MODIFIED)?"MODIFIED":"CLEAN");
DEBUG_PRINT("I am 0x%X%X%X and I have %dKB of flash!\n",
*((int*)(MCU_ID_ADDRESS+8)), *((int*)(MCU_ID_ADDRESS+4)),
*((int*)(MCU_ID_ADDRESS+0)), *((short*)(MCU_FLASH_SIZE_ADDRESS)));
configblockInit();
workerInit();
adcInit();
ledseqInit();
pmInit();
buzzerInit();
isInit = true;
}
int main( int argc, char* argv[] )
{
pmInit( );
elfLoad( "D:\\pspapps\\PSPLife\\DATA.PSP" );
unsigned int uElfEntryPoint = elfEntryPoint();
dynarec_state *state = esCreate( );
dynarec_context *context = ecCreate( state );
eeExecute( context, uElfEntryPoint );
/*
unsigned int* pCurInst = (unsigned int*)pmPtr( 0x08804000 );
for( int i = 0x08804000 ; i <= 0x08804000 + 0x24BB8; i += 4 ) {
const mips_instruction_info* xInst = mdDisassemble( *pCurInst );
if( xInst == 0 ) {
printf( "Unknown instruction %08x @ %08x\n", *pCurInst, i );
}
pCurInst++;
}
*/
system( "PAUSE" );
return 0;
}
int main()
{
systickInit();
memoryInit();
#ifdef BLE
ble_init();
#else
NRF_CLOCK->TASKS_HFCLKSTART = 1UL;
while(!NRF_CLOCK->EVENTS_HFCLKSTARTED);
#endif
#ifdef SEMIHOSTING
initialise_monitor_handles();
#endif
NRF_CLOCK->LFCLKSRC = CLOCK_LFCLKSTAT_SRC_Synth;
NRF_CLOCK->TASKS_LFCLKSTART = 1UL;
while(!NRF_CLOCK->EVENTS_LFCLKSTARTED);
LED_INIT();
if ((NRF_POWER->GPREGRET & 0x80) && ((NRF_POWER->GPREGRET&(0x3<<1))==0)) {
buttonInit(buttonShortPress);
} else {
buttonInit(buttonIdle);
}
if (NRF_POWER->GPREGRET & 0x20) {
boottedFromBootloader = true;
NRF_POWER->GPREGRET &= ~0x20;
}
pmInit();
if ((NRF_POWER->GPREGRET&0x01) == 0) {
pmSetState(pmSysRunning);
}
LED_ON();
NRF_GPIO->PIN_CNF[RADIO_PAEN_PIN] |= GPIO_PIN_CNF_DIR_Output | (GPIO_PIN_CNF_DRIVE_S0H1<<GPIO_PIN_CNF_DRIVE_Pos);
#ifndef BLE
esbInit();
esbSetDatarate(DEFAULT_RADIO_RATE);
esbSetChannel(DEFAULT_RADIO_CHANNEL);
#endif
mainloop();
// The main loop should never end
// TODO see if we should shut-off the system there?
while(1);
return 0;
}
/* This must be the first module to be initialized! */
void systemInit(void)
{
if(isInit)
return;
canStartMutex = xSemaphoreCreateMutex();
xSemaphoreTake(canStartMutex, portMAX_DELAY);
adcInit();
ledseqInit();
pmInit();
isInit = true;
}
void tellManagerJobIsDone(char *managingHost, char *jobIdString, char *line)
/* Try and send message to host saying job is done. */
{
struct paraMessage pm;
bits32 ip;
if (!internetDottedQuadToIp(managingHost, &ip))
{
warn("%s doesn't seem to be in dotted quad form\n", managingHost);
return;
}
pmInit(&pm, ip, paraHubPort);
pmPrintf(&pm, "jobDone %s %s", jobIdString, line);
if (!pmSend(&pm, mainRudp))
warn("Couldn't send message to %s to say %s is done\n", managingHost, jobIdString);
}
/***************************************
* *
* SystemConstruct *
* *
***************************************/
void
SystemConstruct(void)
{
MemConstruct(MAX_HEAPS);
initPrintBuff();
printMsg(PROMPT_MSG, CHARITY_OPEN_MSG);
printMsg(PROMPT_MSG, CHARITY_PROMPT);
initIncludeDirs();
ParserConstruct();
yyin = stdin;
ParseResult.tag = EMPTY_INPUT;
initSymTable(BTRUE);
pmInit();
CodeTableConstruct(CODETAB_HEAP_SIZE);
ctTranslateConstruct();
mc_MachineConstruct();
}
void doResurrect(char *line, struct sockaddr_in *hubIp)
/* Send back I'm alive message */
{
struct paraMessage pm;
struct dlNode *node;
int jobsReported = 0;
pmInit(&pm, ntohl(hubIp->sin_addr.s_addr), paraHubPort);
pmPrintf(&pm, "alive %s", hostName);
for (node = jobsRunning->head; !dlEnd(node); node = node->next)
{
struct job *job = node->val;
pmPrintf(&pm, " %d", job->jobId);
++jobsReported;
}
for (node = jobsFinished->head; !dlEnd(node); node = node->next)
{
struct job *job = node->val;
if (jobsReported >= maxProcs)
break;
pmPrintf(&pm, " %d", job->jobId);
++jobsReported;
}
pmSend(&pm, mainRudp);
}
void doCheck(char *line, struct sockaddr_in *hubIp)
/* Send back check result - either a check in message or
* jobDone. */
{
char *jobIdString = nextWord(&line);
if (jobIdString != NULL)
{
int jobId = atoi(jobIdString);
struct job *job = findRunningJob(jobId);
struct paraMessage pm;
pmInit(&pm, ntohl(hubIp->sin_addr.s_addr), paraHubPort);
if (job != NULL)
pmPrintf(&pm, "checkIn %s %s running", hostName, jobIdString);
else
{
struct job *job = findFinishedJob(jobId);
if (job == NULL)
pmPrintf(&pm, "checkIn %s %s free", hostName, jobIdString);
else
pmPrintf(&pm, "jobDone %s %s", jobIdString, job->doneMessage);
}
pmSend(&pm, mainRudp);
}
}
void execProc(char *managingHost, char *jobIdString, char *reserved,
char *user, char *dir, char *in, char *out, char *err, long long memLimit,
char *exe, char **params)
/* This routine is the child process of doExec.
* It spawns a grandchild that actually does the
* work and waits on it. It sends message to the
* main message loop here when done. */
{
if ((grandChildId = forkOrDie()) == 0)
{
char *homeDir = "";
/* Change to given user (if root) */
changeUid(user, &homeDir);
/* create output files just after becoming user so that errors in the rest
* of this proc will go to the err file and be available via para
* problems */
setupProcStdio(in, out, err);
if (chdir(dir) < 0)
errnoAbort("can't chdir to %s", dir);
setsid();
// setpgid(0,0);
umask(umaskVal);
struct rlimit rlim;
rlim.rlim_cur = rlim.rlim_max = memLimit;
if(setrlimit(RLIMIT_CORE, &rlim) < 0)
perror("setrlimit");
/* Update environment. */
{
struct hash *hash = environToHash(environ);
hashUpdate(hash, "JOB_ID", jobIdString);
hashUpdate(hash, "USER", user);
hashUpdate(hash, "HOME", homeDir);
hashUpdate(hash, "HOST", hostName);
hashUpdate(hash, "PARASOL", "7");
updatePath(hash, userPath, homeDir, sysPath);
addEnvExtras(hash);
environ = hashToEnviron(hash);
freeHashAndVals(&hash);
}
randomSleep(); /* Sleep a random bit before executing this thing
* to help spread out i/o when a big batch of jobs
* hit idle cluster */
execvp(exe, params);
errnoAbort("execvp'ing %s", exe);
}
else
{
/* Wait on executed job and send jobID and status back to
* main process. */
int status = -1;
int cid;
struct paraMessage pm;
struct rudp *ru = NULL;
struct tms tms;
unsigned long uTime = 0;
unsigned long sTime = 0;
if (grandChildId >= 0)
{
signal(SIGTERM, termHandler);
cid = waitpid(grandChildId, &status, 0);
if (cid < 0)
errnoAbort("wait on grandchild failed");
times(&tms);
uTime = ticksToHundreths*tms.tms_cutime;
sTime = ticksToHundreths*tms.tms_cstime;
}
ru = rudpOpen();
if (ru != NULL)
{
ru->maxRetries = 20;
pmInit(&pm, localIp, paraNodePort);
pmPrintf(&pm, "jobDone %s %s %d %lu %lu", managingHost,
jobIdString, status, uTime, sTime);
pmSend(&pm, ru);
rudpClose(&ru);
}
}
}