static void handler(int sig) {
switch (sig) {
case SIGTERM:
__debug("Caught SIGTERM: Scheduling a shutdown");
if (stopping == 1)
__error("Shutdown or reload already scheduled");
else
stopping = 1;
break;
case SIGINT:
__debug("Caught SIGINT: Scheduling a shutdown");
if (stopping == 1)
__error("Shutdown or reload already scheduled");
else
stopping = 1;
break;
case SIGHUP:
__debug("Caught SIGHUP: Scheduling a reload");
if (stopping == 1)
__error("Shutdown or reload already scheduled");
else
stopping = 1, doreload = 1;
break;
default:
__debug("Caught unknown signal %d", sig);
break;
}
}
static int wait_child(euca_opts * args, int pid)
{
time_t timer = 0;
int rc = 0, status;
get_timestamp(ts_buff,sizeof(ts_buff));
fprintf(stderr, "%s INFO Waiting for process to respond to signal.",ts_buff);
while (rc <= 0 && timer < 5) {
usleep(1000000), fprintf(stderr, "."), fflush(stderr);
if ((rc = waitpid(pid, &status, WNOHANG)) == -1) {
__debug("Error waiting for child: pid=%d waitpid=%d status=%d", pid, rc, status);
return errno != ECHILD;
} else if (rc == pid) {
if (WIFEXITED(status)) {
__debug("command terminated with exit status pid=%d waitpid=%d status=%d", pid, rc, WEXITSTATUS(status));
return WEXITSTATUS(status);
} else if (WIFSIGNALED(status)) {
__debug("command terminated by signal pid=%d waitpid=%d status=%d", pid, rc, WTERMSIG(status));
return WTERMSIG(status);
} else {
__debug("command terminated pid=%d waitpid=%d status=%d", pid, rc, status);
return status;
}
} else {
timer++;
continue;
}
}
if (rc == 0 && status == 0) {
fprintf(stderr, "\n");
return 0;
} else {
__error("Failed to signal child process pid=%d waitpid=%d status=%d", pid, rc, status);
return 1;
}
}
static int child( euca_opts *args, java_home_t *data, uid_t uid, gid_t gid ) {
int ret = 0;
jboolean r=0;
__write_pid( GETARG(args,pidfile) );
setpgrp( );
__die(java_init( args, data ) != 1, "Failed to initialize Eucalyptus.");
__die((r=(*env)->CallBooleanMethod(env,bootstrap.instance,bootstrap.init))==0,"Failed to init Eucalyptus.");
__abort(4, set_keys_ownership( GETARG( args, home ), uid, gid ) != 0,"Setting ownership of keyfile failed." );
__abort(4, linuxset_user_group( GETARG( args, user ), uid, gid ) != 0,"Setting the user failed." );
__abort(4, (set_caps(0)!=0), "set_caps (0) failed");
__die((r=(*env)->CallBooleanMethod(env,bootstrap.instance,bootstrap.load))==0,"Failed to load Eucalyptus.");
__die((r=(*env)->CallBooleanMethod(env,bootstrap.instance,bootstrap.start))==0,"Failed to start Eucalyptus.");
handle._hup = signal_set( SIGHUP, handler );
handle._term = signal_set( SIGTERM, handler );
handle._int = signal_set( SIGINT, handler );
child_pid = getpid( );
__debug( "Waiting for a signal to be delivered" );
while( !stopping ) sleep( 60 );
__debug( "Shutdown or reload requested: exiting" );
__die((r=(*env)->CallBooleanMethod(env,bootstrap.instance,bootstrap.stop))==0,"Failed to stop Eucalyptus.");
if( doreload == 1 ) ret = EUCA_RET_RELOAD;
else ret = 0;
__die((r=(*env)->CallBooleanMethod(env,bootstrap.instance,bootstrap.destroy))==0,"Failed to destroy Eucalyptus.");
__die((JVM_destroy( ret ) != 1), "Failed trying to destroy JVM... bailing out seems like the right thing to do" );
return ret;
}
static void shutdown(JNIEnv *env, jobject source, jboolean reload) {
__debug("Shutdown requested (reload is %d)", reload);
if (reload == 1)
__debug("Killing self with HUP signal: %d", kill(child_pid, SIGHUP));
else
__debug("Killing self with TERM signal: %d", kill(child_pid, SIGTERM));
}
static int create_initial_commit(git_repository *repo)
{
git_signature *sign;
git_index *index;
git_oid tree_id, commit_id;
git_tree *tree;
int rc;
git_signature_now(&sign, sign_name, sign_email);
rc = git_repository_index(&index, repo);
if (rc)
__debug("could not open repository index");
rc = git_index_write_tree(&tree_id, index);
if (rc)
__debug("unable to write initial tree from index");
git_index_free(index);
rc = git_tree_lookup(&tree, repo, &tree_id);
if (rc)
__debug("could not look up initial tree");
rc = git_commit_create_v(&commit_id, repo, "HEAD", sign, sign, NULL, "Initial commit", tree, 0);
if (rc)
__debug("could not create the initial commit");
git_tree_free(tree);
git_signature_free(sign);
return rc;
}
static java_home_t *get_java_home( char *path ) {
java_home_t *data = NULL;
char buf[ 1024 ];
int x = -1, k = 0, i = 0;
if( path == NULL ) return NULL;
__debug( "Looking for libjvm in %s", path );
__abort(NULL, (CHECK_ISDIR( path ) == 0 ),"Path %s is not a directory", path );
data = (java_home_t *) malloc( sizeof(java_home_t) );
data->path = strdup( path );
data->jvms = NULL;
data->jnum = 0;
while( libjvm_paths[ ++x ] != NULL ) {
__abort(NULL, ((k = snprintf( buf, 1024, libjvm_paths[ x ], path ) ) <= 0 ),"Error mangling jvm path" );
__debug( "Attempting to locate VM library %s", buf );
if( CHECK_ISREG( buf ) == 1 ) {
data->jvms = (jvm_info_t **) malloc( 2 * sizeof(jvm_info_t *) );
data->jvms[ i ] = (jvm_info_t *) malloc( sizeof(jvm_info_t) );
data->jvms[ i ]->libjvm_path = strdup( buf );
char *dir, *base;
dir = dirname(buf);
base = basename(dir);
data->jvms[ i ]->name = base;
data->jvms[ ++i ] = NULL;
data->jnum = i;
return data;
}
}
return data;
}
uint8_t fsmanInit(uint8_t * result_code, uint8_t* buffer){
struct tm ts;
fsbuf = buffer;
RTC_GetTimeDateDecimal(&ts);
SetClockVars (ts.tm_year, ts.tm_mon, ts.tm_mday, ts.tm_hour, ts.tm_min, ts.tm_sec);
fsmanInitHardwareSD();
if (!fsmanMountSD(result_code)){
*result_code = UNKNOWN_SD_MOUNT_ERROR;//from FILEIO_ERROR_TYPE
return 0;
}
//Create a VI_LOG directory if there isnt already one
if(FSchdir("VI_LOG") != CE_GOOD){
__debug("VI_LOG Directory was not found, creating it");
if(FSmkdir(".\\VI_LOG") != CE_GOOD){
__debug("Unable to create a VI_LOG directory");
*result_code = UNKNOWN_WRITE_ERROR;
return 0;
}
else{
if(FSchdir ("VI_LOG") != CE_GOOD){
*result_code = UNKNOWN_WRITE_ERROR;
__debug("VI_LOG Directory was created but not found");
return 0;
}
}
}
return 1;
}
void euca_load_bootstrapper(void) {
__die((bootstrap.class_name=((*env)->NewStringUTF(env,EUCA_MAIN)))==NULL,"Cannot create string for class name.");
__die((bootstrap.clazz=((*env)->FindClass(env,EUCA_MAIN)))==NULL,"Cannot find Eucalyptus bootstrapper: %s.",EUCA_MAIN);
__debug("Found Eucalyptus bootstrapper: %s",EUCA_MAIN);
__die((bootstrap.class_ref = (*env)->NewGlobalRef(env, bootstrap.clazz))==NULL,"Cannot create global ref for %s.",EUCA_MAIN);
JNINativeMethod shutdown_method = { "shutdown","(Z)V",shutdown };
__die((*env)->RegisterNatives(env,bootstrap.clazz,&shutdown_method,1)!=0,"Cannot register native method: shutdown.");
JNINativeMethod hello_method = { "hello","()V",hello };
__die((*env)->RegisterNatives(env,bootstrap.clazz,&hello_method,1)!=0,"Cannot register native method: hello.");
__debug("Native methods registered.");
__die((bootstrap.constructor=(*env)->GetStaticMethodID(env, bootstrap.clazz,euca_get_instance.method_name, euca_get_instance.method_signature))==NULL,"Failed to get reference to default constructor.");
__die((bootstrap.instance=(*env)->CallStaticObjectMethod(env,bootstrap.clazz,bootstrap.constructor))==NULL,"Failed to create instance of bootstrapper.");
__debug("Created bootstrapper instance.");//TODO: fix all these error messages..
__die((bootstrap.init=(*env)->GetMethodID(env,bootstrap.clazz,euca_init.method_name,euca_init.method_signature))==NULL,"Failed to get method reference for load.");
__debug("-> bound method: init");
__die((bootstrap.load=(*env)->GetMethodID(env,bootstrap.clazz,euca_load.method_name,euca_load.method_signature))==NULL,"Failed to get method reference for load.");
__debug("-> bound method: load");
__die((bootstrap.start=(*env)->GetMethodID(env,bootstrap.clazz,euca_start.method_name,euca_start.method_signature))==NULL,"Failed to get method reference for start.");
__debug("-> bound method: start");
__die((bootstrap.stop=(*env)->GetMethodID(env,bootstrap.clazz,euca_stop.method_name,euca_stop.method_signature))==NULL,"Failed to get method reference for stop.");
__debug("-> bound method: stop");
__die((bootstrap.destroy=(*env)->GetMethodID(env,bootstrap.clazz,euca_destroy.method_name,euca_destroy.method_signature))==NULL,"Failed to get method reference for destroy.");
__debug("-> bound method: destroy");
__die((bootstrap.check=(*env)->GetMethodID(env,bootstrap.clazz,euca_check.method_name,euca_check.method_signature))==NULL,"Failed to get method reference for check.");
__debug("-> bound method: check");
__die((bootstrap.version=(*env)->GetMethodID(env,bootstrap.clazz,euca_version.method_name,euca_version.method_signature))==NULL,"Failed to get method reference for version.");
__debug("-> bound method: version");
}
uint8_t fsmanFormat(void){
__debug("Formatting Drive");
uint8_t res = FSformat (0, 0, "OPENXC");
__debug("Formatting Complete %d",res);
if(res == CE_GOOD)
return 1;
return 0;
}
int JVM_destroy(int code) {
jclass system;
jmethodID method;
__die((system=(*env)->FindClass(env,"java/lang/System"))==NULL,"Cannot find class java/lang/System.");
__die((method=(*env)->GetStaticMethodID(env,system,"exit","(I)V"))==NULL,"Cannot find \"System.exit(int)\" entry point.");
__debug("Calling System.exit(%d)",code);
(*env)->CallStaticVoidMethod(env,system,method,(jint)code);
if ((*jvm)->DestroyJavaVM(jvm)!=0) return 0;
__debug("JVM destroyed.");
return 1;
}
static void controller( int sig ) {
switch( sig ) {
case SIGTERM:
case SIGINT:
case SIGHUP:
__debug( "Forwarding signal %d to process %d", sig, child_pid );
kill( child_pid, sig );
signal( sig, controller );
break;
default:
__debug( "Caught unknown signal %d", sig );
break;
}
}
static int s3_do_check ( char * const signature,
char * const date, char * const resource )
{
char Buf[1024];
CURL* ch = curl_easy_init( );
struct curl_slist *slist=NULL;
snprintf ( Buf, sizeof(Buf), "Date: %s", date );
slist = curl_slist_append(slist, Buf );
snprintf ( Buf, sizeof(Buf), "Authorization: AWS %s:%s", awsKeyID, signature );
slist = curl_slist_append(slist, Buf );
snprintf ( Buf, sizeof(Buf), "http://%s/%s", S3Host, resource );
curl_easy_setopt ( ch, CURLOPT_HTTPHEADER, slist);
curl_easy_setopt ( ch, CURLOPT_URL, Buf );
curl_easy_setopt(ch, CURLOPT_NOBODY, 1);
CURLcode sc = curl_easy_perform(ch);
/** \todo check the return code */
__debug ( "Return Code: %d ", sc );
long response_code;
curl_easy_getinfo(ch, CURLINFO_RESPONSE_CODE, &response_code);
curl_slist_free_all(slist);
curl_easy_cleanup(ch);
if(response_code == 200){
printf("FILE EXISTS\n");
return 1;
}
else{
printf("FILE DOES NOT EXIST\n");
return 0;
}
}
uint8_t fsmanSessionStart(uint8_t * result_code){
//open file here
char file_name[25];
struct tm ts;
uint32_t tm_code;
tm_code = (uint32_t)RTC_GetTimeDateUnix();
RTC_GetTimeDateDecimal(&ts);
SetClockVars (ts.tm_year, ts.tm_mon, ts.tm_mday, ts.tm_hour, ts.tm_min, ts.tm_sec);
sprintf(file_name,"%X.TXT", tm_code);
__debug("Creating %s",file_name);
file = FSfopen (file_name,"w");
if (file == NULL){
*result_code = UNKNOWN_WRITE_ERROR;
return FALSE;
}
return TRUE;
}
/// Handles sending of the data
/// \param ptr pointer to the incoming data
/// \param size size of the data member
/// \param nmemb number of data memebers
/// \param stream pointer to I/O buffer
/// \return number of bytes written
static size_t readfunc ( void * ptr, size_t size, size_t nmemb, void * stream )
{
char * Ln = ptr;
int sz = aws_iobuf_getline ( stream, ptr, size*nmemb);
__debug ( "Sent[%3d] %s", sz, Ln );
return sz;
}
/*
************************************************************************************************************
*
* function
*
* 函数名称：
*
* 参数列表：
*
* 返回值 ：
*
* 说明 ：
*
*
************************************************************************************************************
*/
static void usb_detect_irq_handler(void *p_arg)
{
pusb_struct pusb = &awxx_usb[0];
__u32 temp;
temp = usb_get_bus_interrupt_status(pusb);
usb_clear_bus_interrupt_status(pusb, temp);
__debug("%s,temp=%x\n",__FUNCTION__,temp);
if(temp & 0x04) //reset babble detected,set to usb pc
{
usb_clock_exit();
wBoot_DisableInt(awxx_usb[0].irq_no);
power_ops_int_status |= 0x08;
wBoot_timer_stop(tmr_hd);
wBoot_timer_release(tmr_hd);
tmr_hd = NULL;
__inf("usb set pc\n");
//power_set_usbpc();
usb_working = 0;
}
return;
}
void IfxCpu_Trap_internalProtectionError(uint32 tin)
{
trapWatch = IfxCpu_Trap_extractTrapInfo(IfxCpu_Trap_Class_internalProtection, tin);
IFX_CFG_CPU_TRAP_TSR_HOOK(trapWatch);
__debug();
__asm("rfe");
}
char *java_library(euca_opts *args, java_home_t *data) {
char *libjvm_path=NULL;
int x;
if (data->jnum==0) {
__error("Cannot find any VM in Java Home %s",data->path);
exit(1);
}
if (args->jvm_name_given==0) {
libjvm_path=data->jvms[0]->libjvm_path;
} else {
for (x=0; x<data->jnum; x++) {
if (data->jvms[x]->name==NULL) continue;
if (strcmp(GETARG(args,jvm_name),data->jvms[x]->name)==0) {
libjvm_path=data->jvms[x]->libjvm_path;
break;
}
}
}
if (libjvm_path==NULL) {
__error("Failed to locate usable JVM %s %s",GETARG(args,jvm_name),libjvm_path);
exit(1);
}
__debug("Using libjvm.so in %s",libjvm_path);
return libjvm_path;
}
void IfxCpu_Trap_nonMaskableInterrupt(uint32 tin)
{
trapWatch = IfxCpu_Trap_extractTrapInfo(IfxCpu_Trap_Class_nonMaskableInterrupt, tin);
IFX_CFG_CPU_TRAP_TSR_HOOK(trapWatch);
__debug();
__asm("rfe");
}
void IfxCpu_Trap_memoryManagementError(uint32 tin)
{
trapWatch = IfxCpu_Trap_extractTrapInfo(IfxCpu_Trap_Class_memoryManagement, tin);
IFX_CFG_CPU_TRAP_TSR_HOOK(trapWatch);
__debug();
__asm("rfe");
}
void IfxCpu_Trap_assertion(uint32 tin)
{
trapWatch = IfxCpu_Trap_extractTrapInfo(IfxCpu_Trap_Class_assertion, tin);
IFX_CFG_CPU_TRAP_TSR_HOOK(trapWatch);
__debug();
__asm("rfe");
}
/// Internal function to get configuration file
static FILE * __aws_getcfg ()
{
int rv;
char ConfigFile[256];
/// Compose FileName and check
snprintf ( ConfigFile, sizeof(ConfigFile) - 3, "%s/.awsAuth",
getenv("HOME"));
__debug ( "Config File %s", ConfigFile );
struct stat sBuf;
rv = stat ( ConfigFile, &sBuf );
if ( rv == -1 ) return NULL;
if ( sBuf.st_mode & 066 ||
sBuf.st_uid != getuid () )
{
fprintf ( stderr, "I refuse to read your credentials from %s as this "
"file is readable by, writable by or owned by someone else."
"Try chmod 600 %s", ConfigFile, ConfigFile );
return NULL;
}
return fopen ( ConfigFile, "r" );
}
static void check_error(int error_code, const char *action)
{
const git_error *error = giterr_last();
if (!error_code)
return;
__debug("Error %d %s - %s\n", error_code, action, (error && error->message) ? error->message : "???");
}
int ArchivePanel::OnReportError(ReportErrorStruct* pRE)
{
__debug(_T("Error - %s, %d"), _T("filename"), pRE->nError);
// m_OS.ErrorList.AddError(pRE->pItem->lpFileName);
return 0;
}
void TestDeformer::__debugMeshInfo(const char* msg, MObject &meshMobj)
{
#ifdef _DEBUG
MStatus status;
MFnMesh fnMesh(meshMobj, &status);
CHECK_MSTATUS(status);
__debug("%s(), fnMesh.fullPathName=%s", msg, fnMesh.fullPathName().asChar());
__debug("%s(), fnMesh.name=%s", msg, fnMesh.name().asChar());
MDagPath path; CHECK_MSTATUS(fnMesh.getPath(path));
__debug("%s(), path=%s", msg, path.fullPathName().asChar());
MDagPath dagpath = fnMesh.dagPath(&status); CHECK_MSTATUS(status);
__debug("%s(), dagpath=%s", msg, dagpath.fullPathName().asChar());
MFnDependencyNode fnDNode(meshMobj, &status); CHECK_MSTATUS(status);//
__debug("%s(), name=%s", msg, fnDNode.name().asChar());
MFnDagNode fnDagNode(meshMobj, &status);
CHECK_MSTATUS(status);//
MDagPath path2; CHECK_MSTATUS(fnDagNode.getPath(path2));//
__debug("%s(), path2=%s", msg, path2.fullPathName().asChar());
MDagPath dagpath2 = fnDagNode.dagPath(&status); CHECK_MSTATUS(status);//
__debug("%s(), dagpath2=%s", msg, dagpath2.fullPathName().asChar());
#endif
}
static void test() {
__trace() << "trace message";
__debug() << "debug message";
__info() << "info message";
__notice() << "notice message";
__warn() << "warn message";
__error() << "error message";
__fatal() << "fatal message";
}
/**
* Dump our view of the cluster in the logs.
*/
static void
dump_view(int sig)
{
exa_nodeid_t node_id;
char known_str[EXA_MAX_NODES_NUMBER + 1];
if (sig)
__debug("got signal %d, dumping view", sig);
__debug("incarnation: %hu", self->incarnation);
exa_nodeset_to_bin(&cluster.known_nodes, known_str);
__debug("num_nodes: %u known_nodes: %s", cluster.num_nodes, known_str);
for (node_id = 0; node_id < EXA_MAX_NODES_NUMBER; node_id++)
if (exa_nodeset_contains(&cluster.known_nodes, node_id))
dump_node(sup_cluster_node(&cluster, node_id));
}
static char* __aws_sign ( char * const str )
{
HMAC_CTX ctx;
unsigned char MD[256];
unsigned len;
__debug("StrToSign:%s", str );
HMAC_CTX_init(&ctx);
HMAC_Init(&ctx, awsKey, strlen(awsKey), EVP_sha1());
HMAC_Update(&ctx,(unsigned char*)str, strlen(str));
HMAC_Final(&ctx,(unsigned char*)MD,&len);
HMAC_CTX_cleanup(&ctx);
char * b64 = __b64_encode (MD,len);
__debug("Signature: %s", b64 );
return b64;
}
/// Get Request Date
/// \internal
/// \return date in HTTP format
static char * __aws_get_httpdate ()
{
static char dTa[256];
time_t t = time(NULL);
struct tm * gTime = gmtime ( & t );
memset ( dTa, 0 , sizeof(dTa));
strftime ( dTa, sizeof(dTa), "%a, %d %b %Y %H:%M:%S +0000", gTime );
__debug ( "Request Time: %s", dTa );
return dTa;
}
/**
* Print a view in a file.
*
* \param[in] view View to print
* \param file File to print to
*/
void
sup_view_debug(const sup_view_t *view)
{
char seen_str[EXA_MAX_NODES_NUMBER + 1];
char clique_str[EXA_MAX_NODES_NUMBER + 1];
if (view == NULL)
{
__debug("(null view)");
return;
}
exa_nodeset_to_bin(&view->nodes_seen, seen_str);
exa_nodeset_to_bin(&view->clique, clique_str);
__debug("state=%s seen=%s num_seen=%u clique=%s coord=%u"
" accepted=%u committed=%u", sup_state_name(view->state),
seen_str, view->num_seen, clique_str, view->coord,
view->accepted, view->committed);
}
uint8_t fsmanSessionReset(uint8_t * result_code){
uint32_t pending = fsmanSessionCacheBytesWaiting();
if(pending){
__debug("Resetting session pending to disk %d bytes", pending);
if (FSfwrite ((void *)fsbuf, 1, pending, file) != pending){
*result_code = UNKNOWN_WRITE_ERROR;
__debug("Write pending bytes failed");
file = NULL;
return FALSE;
}else{
fsbufptr = 0;
}
}
if (*result_code = FSfclose(file),
*result_code != CE_GOOD){
return FALSE;
}
return fsmanSessionStart(result_code);
}
