void mac_init(void) { #ifdef NODE_TYPE_DETECTOR lora_init(UART_4, 9600); #endif #ifdef NODE_TYPE_GATEWAY lora_init(UART_1, 9600); #endif portBASE_TYPE res = pdTRUE; res = xTaskCreate(mac_task, //*< task body "MacTask", //*< task name 200, //*< task heap NULL, //*< tasK handle param configMAX_PRIORITIES - 2, //*< task prio NULL); //*< task pointer if (res != pdTRUE) { DBG_LOG(DBG_LEVEL_ERROR, "mac task init failed\r\n"); } mac_queue = xQueueCreate(10, sizeof(osel_event_t)); if (mac_queue == NULL) { DBG_LOG(DBG_LEVEL_ERROR, "mac_queue init failed\r\n"); } mac_sent = xSemaphoreCreateBinary(); if (mac_sent == NULL) { DBG_LOG(DBG_LEVEL_ERROR, "mac_set init failed\r\n"); } }
struct append_entries_output_t *get_append_entries_output(struct data_t *append_entries_response) { struct append_entries_output_t *r = (struct append_entries_output_t *)malloc( sizeof(struct append_entries_output_t)); if(!r) { return NULL; } if(append_entries_response->length != APPEND_ENTRIES_RES_COUNT) { free(r); DBG_LOG(LOG_ERROR, "incorrect number of parameter in RPC response, expected = %d, got = %d", APPEND_ENTRIES_RES_COUNT, append_entries_response->length); return NULL; } for(int i = 0; i < APPEND_ENTRIES_RES_COUNT; i++) { if(!append_entries_response->child[i] || append_entries_response->child[i]->type != RPC_INT || !append_entries_response->child[i]->value) { free(r); if(append_entries_response->child[i]) { DBG_LOG(LOG_ERROR, "incorrect value in param in RPC, expected = %d, got = %d", RPC_INT, append_entries_response->child[i]->type); } return NULL; } } r->term = *(json_int_t *)append_entries_response->child[0]->value; r->success = *(json_int_t *)append_entries_response->child[1]->value; return r; }
void _binpachilti_sink_connect_intern(binpac_sink* sink, const hlt_type_info* type, void** pobj, binpac_parser* parser, hlt_bytes* mtype, hlt_exception** excpt, hlt_execution_context* ctx) { __parser_state* state = hlt_malloc(sizeof(__parser_state)); state->parser = parser; GC_CCTOR(state->parser, hlt_BinPACHilti_Parser, ctx); state->pobj = *pobj; GC_CCTOR_GENERIC(&state->pobj, type, ctx); state->data = 0; state->resume = 0; state->disconnected = 0; state->next = sink->head; sink->head = state; #ifdef DEBUG if ( mtype ) { hlt_string s = hlt_string_decode(mtype, Hilti_Charset_ASCII, excpt, ctx); char* r1 = hlt_string_to_native(s, excpt, ctx); char* r2 = hlt_string_to_native(parser->name, excpt, ctx); DBG_LOG("binpac-sinks", "connected parser %s [%p] to sink %p for MIME type %s", r2, *pobj, sink, r1); hlt_free(r1); hlt_free(r2); } else { char* p = hlt_string_to_native(parser->name, excpt, ctx); DBG_LOG("binpac-sinks", "connected parser %s [%p] to sink %p", p, *pobj, sink); hlt_free(p); } #endif }
/******************************************************************************* Function *******************************************************************************/ static void autolink_mcu_parse_radio_savereq(uint8* data,uint32 len) { sint32 freq = byte_to_int(0,0,data[2],data[3]); switch(data[0]) { case MCU_RADIO_DATA1_ALREADY_SAVEFREQ_BAND_FM: mcu_info_data.radio.save.band = RADIO_BAND_FM; mcu_info_data.radio.save.freq = (float)freq/100; DBG_LOG("GET:save freq FM %f\n",mcu_info_data.radio.save.freq); break; case MCU_RADIO_DATA1_ALREADY_SAVEFREQ_BAND_AM: mcu_info_data.radio.save.band = RADIO_BAND_AM; mcu_info_data.radio.save.freq = freq; DBG_LOG("GET:save freq AM %d\n",mcu_info_data.radio.save.freq); break; default: ERR_LOG("GET:save freq unkown\n"); return; } mcu_info_data.radio.save.freq_position = data[1]; DBG_LOG("GET:save freq radio position %d\n",mcu_info_data.radio.save.freq_position); autolink_emit_mcu_state(TYPE_RADIO_SAVEFREQ,mcu_info_data); return; }
void binpac_dbg_reassembler_buffer(binpac_sink* sink, const char* msg, hlt_exception** excpt, hlt_execution_context* ctx) { #ifdef DEBUG if ( ! sink->first_chunk ) { DBG_LOG("binpac-sinks", "reassembler/%p: no data buffered", sink); return; } char buffer[128]; int i = 0; uint64_t initial_seq; // Initial sequence number. uint64_t cur_rseq; // Sequence of last delivered byte + 1 (i.e., seq of next) uint64_t last_reassem_rseq; // Sequence of last byte reassembled and delivered + 1. uint64_t trim_rseq; // Sequence of last byte trimmed so far + 1. __chunk* first_chunk; // First not yet reassembled chunk. Has ownership. __chunk* last_chunk; // Last not yet reassembled chunk. DBG_LOG("binpac-sinks", "reassembler/%p: %s (" "cur_rseq=%" PRIu64 " " "last_reassem_rseq=%" PRIu64 " " "trim_rseq=%" PRIu64 ")", sink, msg, sink->cur_rseq, sink->last_reassem_rseq, sink->trim_rseq); for ( __chunk* c = sink->first_chunk; c; c = c->next ) { snprintf(buffer, sizeof(buffer), "* chunk %d:", i); binpac_dbg_reassembler(sink, buffer, c->data, c->rseq, (c->rupper - c->rseq), excpt, ctx); i++; } #endif }
struct data_t *make_request_vote_rpc_response(struct request_vote_output_t *output) { struct data_t *res = (struct data_t *)malloc(sizeof(struct data_t)); if(!res){ DBG_LOG(LOG_FATAL, "memory allocation failed"); return NULL; } res->type = RPC_VECTOR; res->length = REQUEST_VOTE_RES_COUNT; res->child = (struct data_t **)malloc( sizeof(struct data_t *)*REQUEST_VOTE_RES_COUNT); if(!res->child) { free(res); DBG_LOG(LOG_FATAL, "memory allocation failed"); return NULL; } res->child[0] = uint64_to_data_t(output->term); res->child[1] = uint32_to_data_t(output->vote_granted); for(int i = 0; i < REQUEST_VOTE_RES_COUNT; i++) { if(!res->child[i]) { res->length = i; free_data_t(res); DBG_LOG(LOG_FATAL, "memory allocation failed"); return NULL; } } return res; }
struct method_t *make_request_vote_rpc_method(struct request_vote_input_t *input) { struct data_t **params = (struct data_t **)malloc( sizeof(struct data_t *)*REQUEST_VOTE_PARAM_COUNT); if(!params) { DBG_LOG(LOG_FATAL, "memory allocation failed"); return NULL; } params[0] = uint64_to_data_t(input->term); params[1] = uint32_to_data_t(input->candidate_id); params[2] = uint64_to_data_t(input->last_log_index); params[3] = uint64_to_data_t(input->last_log_term); char *method_name = private_strdup(REQUEST_VOTE_RPC); struct method_t *request_vote = (struct method_t *)malloc(sizeof(struct method_t)); if(!request_vote) { DBG_LOG(LOG_FATAL, "memory allocation failed"); if(method_name) free(method_name); for(int i = 0; i < REQUEST_VOTE_PARAM_COUNT; i++) { if(params[i]) { free_data_t(params[i]); } } free(params); return NULL; } request_vote->name = method_name; request_vote->params = params; request_vote->nparams = REQUEST_VOTE_PARAM_COUNT; return request_vote; }
int16_t Z_OSCMessage::setZ_OSCAddress(const char *_address){ oscAdrSize=(uint16_t)strlen(_address); if( oscAdrSize > kMaxZ_OSCAdrCharactor ){ DBG_LOGLN("set Z_OSC max Z_OSC Adr err"); flush(); return 1; } if(oscAddress!=NULL) free(oscAddress); oscAddress=(char*)calloc(1,oscAdrSize+1); strcpy(oscAddress,_address); oscAdrPacSize=getPackSize(oscAdrSize); DBG_LOG("set Z_OSC Adr:"); DBG_LOG(oscAddress); DBG_LOG(" size:"); DBG_LOG(oscAdrSize); DBG_LOG(" packsize:"); DBG_LOGLN(oscAdrPacSize); return 0; }
int16_t Z_OSCMessage::setTypeTags(const char *_tags ){ uint8_t maxErr=0; argsNum=(uint16_t)strlen(_tags); if(argsNum > kMaxAugument){ DBG_LOGLN("set tags max arg err"); flush(); return 1; } typeTagSize = argsNum+1; if(typeTag!=NULL) free(typeTag); typeTag=(char*)calloc(1,argsNum+1); strcpy(typeTag,_tags); typeTagPacSize=getPackSize(typeTagSize); argsNum=typeTagSize; DBG_LOG("set TypeTag:"); DBG_LOG(typeTag); DBG_LOG(" size:"); DBG_LOG(typeTagSize); DBG_LOG(" packsize:"); DBG_LOGLN(typeTagPacSize); return 0; }
struct data_t *make_append_entries_rpc_response(struct append_entries_output_t *output) { struct data_t *res = (struct data_t *)malloc(sizeof(struct data_t)); if(!res){ DBG_LOG(LOG_FATAL, "memory allocation failed"); return NULL; } res->type = RPC_VECTOR; res->length = APPEND_ENTRIES_RES_COUNT; res->child = (struct data_t **)malloc( sizeof(struct data_t *)*APPEND_ENTRIES_RES_COUNT); if(!res->child) { free(res); DBG_LOG(LOG_FATAL, "memory allocation failed"); return NULL; } res->child[0] = uint64_to_data_t(output->term); res->child[1] = uint32_to_data_t(output->success); for(int i = 0; i < REQUEST_VOTE_RES_COUNT; i++) { if(!res->child[i]) { res->length = i; free_data_t(res); DBG_LOG(LOG_FATAL, "memory allocation failed"); return NULL; } } return res; }
static int pxy_http_epollin(int fd, void * private_data) { con_t * con = (con_t *)private_data; int rlen; int ret; rlen = MAX_CB_BUF - con->cb_totlen; ret = recv(fd, &con->cb_buf[con->cb_totlen], rlen, 0); if(ret <= 0) { DBG_LOG(MSG, MOD_PROXYD, "[closing fd:%d]recv returned %d." , fd, ret) ; close_conn(fd); return TRUE; } con->cb_totlen += ret; if (CHECK_CON_FLAG(con, CONF_CLIENT_SIDE)) { glob_pxy_tot_size_from_client += ret; } else { glob_pxy_tot_size_from_origin_svr += ret; } DBG_LOG(MSG, MOD_PROXYD, "[fd:%d]recv returned %d., fwding data to peer" , fd, ret) ; forward_data_to_peer(con); return TRUE; }
/******************************************************************************* Function Definition *******************************************************************************/ static void autolink_mcu_packet_parse(uint8 cmd1,uint8* data, sint8 len) { DBG_LOG("NEW MSG\n"); DBG_LOG("CMD1=%X\n",cmd1); switch(cmd1) { case MCU_CMD_SYSTEM: autolink_mcu_parse_system(data,len); break; case MCU_CMD_KEY: autolink_mcu_parse_key(data,len); break; case MCU_CMD_RADIO: autolink_mcu_parse_radio(data,len); break; case MCU_CMD_SETTING: autolink_mcu_parse_setting(data,len); break; case MCU_CMD_MEDIA: autolink_mcu_parse_media(data,len); break; case MCU_CMD_UPDATE: autolink_mcu_parse_update(data,len); break; case MCU_CMD_CAN: autolink_mcu_parse_can(data,len); break; default: ERR_LOG("UNKOWN MSG\n"); break; } return ; }
struct request_vote_input_t *get_request_vote_input_params(struct data_t *params[], int nparams) { struct request_vote_input_t *r = (struct request_vote_input_t *)malloc(sizeof(struct request_vote_input_t)); if(!r) { return NULL; } if(nparams != REQUEST_VOTE_PARAM_COUNT) { free(r); DBG_LOG(LOG_ERROR, "incorrect number of parameter in RPC, expected = %d, got = %d", REQUEST_VOTE_PARAM_COUNT, nparams); return NULL; } for(int i = 0; i < REQUEST_VOTE_PARAM_COUNT; i++) { if(!params[i] || params[i]->type != RPC_INT || !params[i]->value) { free(r); if(params[i]) { DBG_LOG(LOG_ERROR, "incorrect value in %dth param in RPC, expected = %d, got = %d, value = %x", (i+1), RPC_INT, params[i]->type, params[i]->value); } return NULL; } } r->term = *(json_int_t *)params[0]->value; r->candidate_id = *(json_int_t *)params[1]->value; r->last_log_index = *(json_int_t *)params[2]->value; r->last_log_term = *(json_int_t *)params[3]->value; return r; }
UILayoutHandle* UILayoutFactory::Load(const char* url) { int url_hash = StringHelper::Hash(url); // Texture already loaded? if (m_loaded_layouts.Contains(url_hash)) { DBG_LOG("Loaded layout from cache: %s", url); return m_loaded_layouts.Get(url_hash); } // Try and load texture! UILayout* layout = Load_Without_Handle(url); if (layout != NULL) { UILayoutHandle* handle = new UILayoutHandle(url, layout); m_loaded_layouts.Set(url_hash, handle); DBG_LOG("Loaded UI layout: %s", url); return handle; } else { DBG_LOG("Failed to load UI layout: %s", url); } return NULL; }
int VPEMGR_init(void) { int rv; pthread_attr_t attr; int stacksize = 128 * KiBYTES; LIST_INIT( &vpemgr_req_head ); rv = pthread_attr_init(&attr); if (rv) { DBG_LOG(MSG, MOD_VPEMGR, "pthread_attr_init() failed, rv=%d", rv); return 0; } rv = pthread_attr_setstacksize(&attr, stacksize); if (rv) { DBG_LOG(MSG, MOD_VPEMGR, "pthread_attr_setstacksize() failed, rv=%d", rv); return 0; } if( pthread_create(&vpemgr_req_thread_id, &attr, vpemgr_req_func, NULL)) { DBG_LOG(MSG, MOD_VPEMGR, "Failed to create thread %s VPEMGR Initialization unsuccessful", ""); return 0; } glob_vpemgr_tot_reqs=0; glob_vpemgr_err_dropped=0; return 1; }
struct request_vote_output_t *get_request_vote_output(struct data_t *request_vote_response) { struct request_vote_output_t *r = (struct request_vote_output_t *)malloc( sizeof(struct request_vote_output_t)); if(!r) { return NULL; } if(request_vote_response->length != REQUEST_VOTE_RES_COUNT) { free(r); DBG_LOG(LOG_ERROR, "incorrect number of parameter in RPC response, expected = %d, got = %d", REQUEST_VOTE_RES_COUNT, request_vote_response->length); return NULL; } for(int i = 0; i < REQUEST_VOTE_RES_COUNT; i++) { if(!request_vote_response->child[i] || request_vote_response->child[i]->type != RPC_INT || !request_vote_response->child[i]->value) { free(r); if(request_vote_response->child[i]) { DBG_LOG(LOG_ERROR, "incorrect value in %dth param in RPC, expected = %d, got = %d", (i+1), RPC_INT, request_vote_response->child[i]->type); } return NULL; } } r->term = *(json_int_t *)request_vote_response->child[0]->value; r->vote_granted = *(json_int_t *)request_vote_response->child[1]->value; return r; }
static void __trim(binpac_sink* sink, uint64_t rseq, void* user, hlt_exception** excpt, hlt_execution_context* ctx) { #ifdef DEBUG if ( rseq != UINT64_MAX ) { DBG_LOG("binpac-sinks", "trimming sink %p to rseq %" PRIu64, sink, rseq); } else { DBG_LOG("binpac-sinks", "trimming sink %p to eod", sink); } #endif __chunk* c = sink->first_chunk; while ( c ) { if ( c->rupper > rseq ) break; if ( c->rupper < sink->cur_rseq && c->data ) __report_undelivered(sink, c->rseq, c->data, user, excpt, ctx); __chunk* n = c->next; __unlink_chunk(sink, c, excpt, ctx); __delete_chunk(c, excpt, ctx); c = n; } sink->trim_rseq = rseq; }
Atlas* AtlasResourceCompiler::Load_Compiled() { std::string compiled_path = Get_Compiled_Path(); Platform* platform = Platform::Get(); // Compile time. DBG_LOG("Loading atlas resource '%s'.", compiled_path.c_str()); // Load configuration settings. ConfigFile config; if (!config.Load(compiled_path.c_str())) { DBG_LOG("Failed to load atlas, config file could not be found: '%s'", compiled_path.c_str()); return NULL; } // Load the compile atlas file. Atlas* atlas = new Atlas(); if (!atlas->Load_Compiled_Config(&config)) { return NULL; } DBG_LOG("Finished loading compiled atlas from '%s'.", compiled_path.c_str()); return atlas; }
GLuint CreateProgram(PP_Resource context, PPB_OpenGLES2* gl, const char* vs, const char* ps) { GLuint shaders[2]; GLuint program; GLint status = 0; shaders[0] = gl->CreateShader(context, GL_VERTEX_SHADER); gl->ShaderSource(context, shaders[0], 1, &vs, 0); gl->CompileShader(context, shaders[0]); gl->GetShaderiv(context, shaders[0], GL_COMPILE_STATUS, &status); if(!status) { char aszMessage[300]; char aszShaderLog[256]; gl->GetShaderInfoLog(context, shaders[0], 256, 0, aszShaderLog); sprintf(aszMessage, DBG_LOG_PREFIX"Failed to vertex compile shader\n%s\n", aszShaderLog); DBG_LOG(aszMessage); } shaders[1] = gl->CreateShader(context, GL_FRAGMENT_SHADER); gl->ShaderSource(context, shaders[1], 1, &ps, 0); gl->CompileShader(context, shaders[1]); gl->GetShaderiv(context, shaders[1], GL_COMPILE_STATUS, &status); if(!status) { char aszMessage[300]; char aszShaderLog[256]; gl->GetShaderInfoLog(context, shaders[1], 256, 0, aszShaderLog); sprintf(aszMessage, DBG_LOG_PREFIX"Failed to pixel compile shader\n%s\n", aszShaderLog); DBG_LOG(aszMessage); } program = gl->CreateProgram(context); gl->AttachShader(context, program, shaders[0]); gl->AttachShader(context, program, shaders[1]); gl->BindAttribLocation(context, program, VA_POSITION_INDEX, "Position"); gl->BindAttribLocation(context, program, VA_TEXCOORD_INDEX, "TexCoords0"); gl->BindAttribLocation(context, program, VA_NORMAL_INDEX, "Normal"); gl->LinkProgram(context, program); gl->GetProgramiv(context, program, GL_LINK_STATUS, &status); if(!status) { DBG_LOG(DBG_LOG_PREFIX"Failed to link program\n"); } return program; }
/******************************************************************************* Function *******************************************************************************/ extern sint32 autolink_send_mcu_radio_set_freq(autolink_radio_st radio) { uint8 cmd; uint8 msg_data[DATA_LEN_MAX]; uint8 len = 0; cmd = MCU_CMD_RADIO; msg_data[0] = MCU_RADIO_DATA0_ARMSET_FREQ; DBG_LOG("SEND:set band %d\n",radio.set.band); switch(radio.set.band) { case RADIO_BAND_FM: msg_data[1] = MCU_RADIO_DATA1_ARMSET_BAND_FM; break; case RADIO_BAND_AM: msg_data[1] = MCU_RADIO_DATA1_ARMSET_BAND_AM; break; default: ERR_LOG("UNKOWN MSG\n"); return -1; } DBG_LOG("SEND:set freq_position %d\n",radio.set.freq_position); msg_data[2] = radio.set.freq_position; DBG_LOG("SEND:set type %d\n",radio.set_type); switch(radio.set_type) { case RADIO_SET_SELECT: msg_data[3] = MCU_RADIO_DATA1_ARMSET_SELECT; break; case RADIO_SET_SAVE: msg_data[3] = MCU_RADIO_DATA1_ARMSET_SAVE; break; default: ERR_LOG("UNKOWN MSG\n"); return -1; } DBG_LOG("SEND:set freq %f\n",radio.set.freq); switch(radio.set.band) { case RADIO_BAND_AM: int_to_byte(radio.set.freq,NULL,NULL,&msg_data[4],&msg_data[5]); break; case RADIO_BAND_FM: int_to_byte(radio.set.freq*100,NULL,NULL,&msg_data[4],&msg_data[5]); break; default: ERR_LOG("UNKOWN MSG\n"); return -1; } len = 6; return autolink_mcu_send_msg(1,cmd,msg_data,len); }
int start_server(struct server_context_t *s, int clientport) { DBG_LOG(LOG_INFO, "[%s][%d] starting client handler at port = %d", ss[s->state], s->current_term, clientport); start_client_handler(s, clientport); DBG_LOG(LOG_INFO, "[%s][%d] starting server's event loop", ss[s->state], s->current_term); return event_base_dispatch(s->base); }
int unset_process_local_rank() { FILE *flock = NULL; FILE *fcounter = NULL; int expired = 0; int process_id; if (latency_model.max_local_processe_ranks < 2) { return E_SUCCESS; } DBG_LOG(DEBUG, "Unsetting process local rank\n"); while (expired < MAX_LOCKED_RETRIES) { // open lock file on Exclusive mode flock = fopen(EMUL_LOCK_FILE, "wx"); if (flock == NULL) { // DBG_LOG(DEBUG, "failed to create lock file\n"); usleep(LOCKED_WAIT_US); expired++; } if (flock) break; } if (expired >= MAX_LOCKED_RETRIES) { DBG_LOG(ERROR, "failed to unset process local rank\n"); return E_ERROR; } // lock acquired, read process counter file if (access(EMUL_PROCESS_LOCAL_RANK_FILE, R_OK | W_OK) == 0) { // if rank file does not exist, nothing to be done // file exists, read the current value and decrement it fcounter = fopen(EMUL_PROCESS_LOCAL_RANK_FILE, "r+"); if (fread(&process_id, sizeof(int), 1, fcounter) == 0) { abort(); } DBG_LOG(DEBUG, "Exiting process and reading current rank max %d\n", process_id); if (process_id > 0) process_id--; { char hname[64]; gethostname(hname, sizeof(hname)); DBG_LOG(DEBUG, "Exiting process and writing new rank max %d on %s\n", process_id, hname); } rewind(fcounter); fwrite(&process_id, sizeof(int), 1, fcounter); fclose(fcounter); } // close and delete lock file fclose(flock); remove(EMUL_LOCK_FILE); return E_SUCCESS; }
void binpac_dbg_reassembler(binpac_sink* sink, const char* msg, hlt_bytes* data, uint64_t seq, int64_t len, hlt_exception** excpt, hlt_execution_context* ctx) { #ifdef DEBUG // Log data with non-printable characters escaped and output trimmed if // too long. const char* dots = 0; int8_t buffer[50]; buffer[0] = '\0'; hlt_bytes_size dlen = 0; if ( data ) { int i = 0; hlt_iterator_bytes p = hlt_bytes_begin(data, excpt, ctx); hlt_iterator_bytes end = hlt_bytes_end(data, excpt, ctx); while ( ! hlt_iterator_bytes_eq(p, end, excpt, ctx) ) { int8_t c = hlt_iterator_bytes_deref(p, excpt, ctx); if ( isprint(c) ) buffer[i++] = c; else { if ( i < sizeof(buffer) - 5 ) i += snprintf((char*)(buffer + i), 5, "\\x%02x", c); else break; } if ( i >= sizeof(buffer) - 1 ) break; p = hlt_iterator_bytes_incr(p, excpt, ctx); } buffer[i] = '\0'; dlen = hlt_bytes_len(data, excpt, ctx); dots = hlt_iterator_bytes_eq(p, end, excpt, ctx) ? "" : " ..."; } if ( data ) { if ( len >= 0 ) DBG_LOG("binpac-sinks", "reassembler/%p: %s seq=% " PRIu64 " upper=%" PRIu64 " |%s%s| (%" PRIu64 " bytes)", sink, msg, seq, seq + len, buffer, dots, dlen); else DBG_LOG("binpac-sinks", "reassembler/%p: %s seq=% " PRIu64 " |%s%s| (%" PRIu64 " bytes)", sink, msg, seq, buffer, dots, dlen); } else { if ( len >= 0 ) DBG_LOG("binpac-sinks", "reassembler/%p: %s seq=%" PRIu64 " upper=%" PRIu64 " <GAP>", sink, msg, seq, seq + len); else DBG_LOG("binpac-sinks", "reassembler/%p: %s seq=%" PRIu64 " <GAP>", sink, msg, seq); } #endif }
/* * method to print nknexecd_retval_t */ void nknexecd_print_retval(nknexecd_retval_t *retval) { DBG_LOG(MSG, MOD_NKNEXECD, "in nknexecd_print_retval"); DBG_LOG(MSG, MOD_NKNEXECD, "retval.retval_reply_code is %d", retval->retval_reply_code); DBG_LOG(MSG, MOD_NKNEXECD, "retval->stdoutfile is %s", retval->retval_stdoutfile); DBG_LOG(MSG, MOD_NKNEXECD, "retval->stderrfile is %s", retval->retval_stderrfile); } /* nknexecd_print_retval */
int load_sparse_matrix_coo(mat_file_ctx_t *ctx, int *row_indeces, int *col_indeces, double *values) { int ret = 0; int i = 0; ssize_t read; size_t len = 0; if (!MAT_FILE_CTX_INITED(ctx)) { return -1; } /* First line with data is stored in ctx->cur_line. * This line was read during parsing preamble */ do { int row_idx, col_idx; double value; sscanf(ctx->cur_line, "%d %d %lf\n", &row_idx, &col_idx, &value); if ((row_idx > ctx->preamble.rows_cnt) || (col_idx > ctx->preamble.cols_cnt)) { DBG_LOG("Element index is out of range, ctx->cur_line %d\n", ctx->cur_line_no); ret = -1; } else { row_indeces[i] = row_idx - 1; col_indeces[i] = col_idx - 1; values[i] = value; } read = getline(&ctx->cur_line, &len, ctx->f); if (read != -1) { ctx->cur_line_no++; } else { DBG_LOG("Error: too few rows in file\n"); ret = -1; } i++; } while ((i < ctx->preamble.nnz) && (ret == 0)); return ret; }
/* load a texture from a file to currently bound texture */ int engine_texture_loadfile(const char *filename) { SDL_Surface *surf; GLint format; const GLint bgra_swizzle[] = {GL_BLUE, GL_GREEN, GL_RED, GL_ALPHA}; const GLint bgr_swizzle[] = {GL_BLUE, GL_GREEN, GL_RED, GL_ONE }; const GLint red_swizzle[] = { GL_RED, GL_RED, GL_RED, GL_ONE }; // TODO: support other file types ... surf = SDL_LoadBMP(filename); if (!surf) { DBG_LOG("ERROR:%s:%s", filename, SDL_GetError()); return -1; } DBG_LOG("image \"%s\" %dx%d,%d (pitch %d)", filename, surf->w, surf->h, surf->format->BitsPerPixel, surf->pitch); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); switch (surf->format->BytesPerPixel) { case 4: format = GL_RGBA; glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, bgra_swizzle); break; case 3: format = GL_RGB; glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, bgr_swizzle); break; case 1: /* one channel / intensity - shader will have to deal with palette */ format = GL_RED; glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, red_swizzle); memset(surf->pixels, 255, surf->h * surf->pitch); // Hack in some pixels break; default: DBG_LOG("ERROR:%s:unsupported image depth %d", filename, surf->format->BytesPerPixel); SDL_FreeSurface(surf); return -1; } glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, surf->w, surf->h, 0, format, GL_UNSIGNED_BYTE, surf->pixels); log_gl_error(); SDL_FreeSurface(surf); return 0; }
static int add_to_bucket(net_timer_data_t *nd, int interval_msecs) { int64_t msecs; int bucket; int rv; clock_gettime(CLOCK_MONOTONIC, &nd->deadline_ts); pthread_mutex_lock(&hrt_thread_mutex); msecs = timespec_diff_msecs(&HRT_BASE_BUCKET_TS, &nd->deadline_ts); if (msecs < 0) { msecs = 0; } msecs += interval_msecs; timespec_add_msecs(&nd->deadline_ts, interval_msecs); if (msecs > MAX_INT_INTERVAL_MSECS) { /* * HRT thread has not run in greater than MAX_INT_INTERVAL_MSECS, * signal it to process requests and return a retry indication. */ rv = pthread_cond_signal(&hrt_thread_cv); if (rv) { glob_hrt_cond_signal_failed++; DBG_LOG(SEVERE, MOD_HRT, "CV signal failed, rv=%d", rv); DBG_ERR(SEVERE, "CV signal failed, rv=%d", rv); } pthread_mutex_unlock(&hrt_thread_mutex); glob_hrt_invalid_interval++; return -1; // Retry } bucket = MSECS_TO_BUCKET(msecs); bucket = (HRT_BASE_BUCKET + bucket) % TIMER_BUCKETS; NTD_LINK_TAIL(&timer_bucket[bucket], nd, active_timer_data); TRACE_BUCKET(bucket); if (HRT_THREAD_SLEEPING && (timespec_cmp(&nd->deadline_ts, &HRT_THREAD_TS) < 0)) { /* * HRT Thread is sleeping beyond this request's timeout, signal it * to recompute the sleep interval. */ rv = pthread_cond_signal(&hrt_thread_cv); if (rv) { glob_hrt_cond_signal_failed++; DBG_LOG(SEVERE, MOD_HRT, "CV(2) signal failed, rv=%d", rv); DBG_ERR(SEVERE, "CV(2) signal failed, rv=%d", rv); } } pthread_mutex_unlock(&hrt_thread_mutex); return 0; // Success }
/**@brief Proximity Application initialization * start the device scanning process */ static void pxp_app_init(void) { at_ble_status_t scan_status; /* Initialize the scanning procedure */ scan_status = gap_dev_scan(); /* Check for scan status */ if (scan_status == AT_BLE_INVALID_PARAM) { DBG_LOG("Scan parameters are invalid"); } else if (scan_status == AT_BLE_FAILURE) { DBG_LOG("Scanning Failed Generic error"); } }
int main(int argc, char *argv[]) { if(argc < 2) { printf("Usage: raftd <id> <basedir>\n"); return 1; } base64_init(); int id = atoi(argv[1]); if(id < 1 || id > 3) { printf("Usage: raftd <id>\n"); printf("provided <id> > 0 && <id> <= 3\n"); return 1; } srandom(id); verbosity = LOG_DEBUG; struct server_context_t *s = init_raft_server(id, argv[2], "0.0.0.0", ports[id - 1], HTTP, 1000000l, 500000l); int peers[2]; int peer_ports[2]; for(int i = 1, j = 0; i <= 3; i++) { if(id != i) { peers[j] = i; peer_ports[j] = ports[i - 1]; j++; } } printf("Server port = %d\n", ports[id - 1]); printf("Peer ports = %d %d\n", peer_ports[0], peer_ports[1]); const char *hosts[] = { "0.0.0.0", "0.0.0.0" }; if(s) { if(add_pairs(s, 2, peers, hosts, peer_ports)) { DBG_LOG(LOG_FATAL, "[%s][%d] Error while adding peers to server", ss[s->state], s->current_term); deinit_raft_server(s); return 1; } } else { DBG_LOG(LOG_FATAL, "[?][?] Error while creating server instance"); exit(1); } int clientport = ports[id - 1] + 10; printf("Client port = %d\n", clientport); start_server(s, clientport); deinit_raft_server(s); base64_cleanup(); return 0; }
int logi_dma_open(struct drvr_mem* mem_dev, dma_addr_t *physbuf) { #ifdef USE_DMA_ENGINE struct dma_slave_config conf; dma_cap_mask_t mask; #endif /* Allocate DMA buffer */ mem_dev->dma.buf = dma_alloc_coherent(NULL, MAX_DMA_TRANSFER_IN_BYTES, &dmaphysbuf, 0); if (!mem_dev->dma.buf) { DBG_LOG("failed to allocate DMA buffer\n"); return -ENOMEM; } *physbuf = dmaphysbuf; #ifdef USE_DMA_ENGINE /* Allocate DMA channel */ dma_cap_zero(mask); dma_cap_set(DMA_MEMCPY, mask); mem_dev->dma.chan = dma_request_channel(mask, NULL, NULL); if (!mem_dev->dma.chan) return -ENODEV; /* Configure DMA channel */ conf.direction = DMA_MEM_TO_MEM; /*conf.dst_addr_width = DMA_SLAVE_BUSWIDTH_2_BYTES;*/ dmaengine_slave_config(mem_dev->dma.chan, &conf); DBG_LOG("Using Linux DMA Engine API"); #else mem_dev->dma.dma_chan = edma_alloc_channel(EDMA_CHANNEL_ANY, dma_callback, NULL, EVENTQ_0); if (mem_dev->dma.dma_chan < 0) { DBG_LOG("edma_alloc_channel failed for dma_ch, error: %d\n", mem_dev->dma.dma_chan); return mem_dev->dma.dma_chan; } DBG_LOG("Using EDMA/DMA Engine"); #endif /* USE_DMA_ENGINE */ DBG_LOG("EDMA channel %d reserved\n", mem_dev->dma.dma_chan); return 0; }