static inline int s1ap_eNB_encode_successfull_outcome(s1ap_message *s1ap_message_p, uint8_t **buffer, uint32_t *len) { int ret = -1; MessageDef *message_p; char *message_string = NULL; size_t message_string_size; MessagesIds message_id; DevAssert(s1ap_message_p != NULL); message_string = calloc(10000, sizeof(char)); s1ap_string_total_size = 0; message_string_size = strlen(message_string); switch(s1ap_message_p->procedureCode) { case S1ap_ProcedureCode_id_InitialContextSetup: ret = s1ap_eNB_encode_initial_context_setup_response( &s1ap_message_p->msg.s1ap_InitialContextSetupResponseIEs, buffer, len); s1ap_xer_print_s1ap_initialcontextsetupresponse(s1ap_xer__print2sp, message_string, s1ap_message_p); message_id = S1AP_INITIAL_CONTEXT_SETUP_LOG; message_p = itti_alloc_new_message_sized(TASK_S1AP, message_id, message_string_size + sizeof (IttiMsgText)); message_p->ittiMsg.s1ap_initial_context_setup_log.size = message_string_size; memcpy(&message_p->ittiMsg.s1ap_initial_context_setup_log.text, message_string, message_string_size); itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p); free(message_string); break; case S1ap_ProcedureCode_id_UEContextRelease: ret = s1ap_eNB_encode_ue_context_release_complete( &s1ap_message_p->msg.s1ap_UEContextReleaseCompleteIEs, buffer, len); s1ap_xer_print_s1ap_uecontextreleasecomplete(s1ap_xer__print2sp, message_string, s1ap_message_p); message_id = S1AP_UE_CONTEXT_RELEASE_COMPLETE_LOG; message_p = itti_alloc_new_message_sized(TASK_S1AP, message_id, message_string_size + sizeof (IttiMsgText)); message_p->ittiMsg.s1ap_ue_context_release_complete_log.size = message_string_size; memcpy(&message_p->ittiMsg.s1ap_ue_context_release_complete_log.text, message_string, message_string_size); itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p); free(message_string); break; default: S1AP_DEBUG("Unknown procedure ID (%d) for successfull outcome message\n", (int)s1ap_message_p->procedureCode); return ret; break; } return ret; }
static int s1ap_eNB_decode_successful_outcome(s1ap_message *message, S1ap_SuccessfulOutcome_t *successfullOutcome_p) { int ret = -1; MessageDef *message_p; char *message_string = NULL; size_t message_string_size; MessagesIds message_id; DevAssert(successfullOutcome_p != NULL); message_string = malloc(sizeof(char) * 10000); s1ap_string_total_size = 0; message->procedureCode = successfullOutcome_p->procedureCode; message->criticality = successfullOutcome_p->criticality; switch(successfullOutcome_p->procedureCode) { case S1ap_ProcedureCode_id_S1Setup: ret = s1ap_decode_s1ap_s1setupresponseies( &message->msg.s1ap_S1SetupResponseIEs, &successfullOutcome_p->value); s1ap_xer_print_s1ap_s1setupresponse(s1ap_xer__print2sp, message_string, message); message_id = S1AP_S1_SETUP_LOG; break; default: S1AP_ERROR("Unknown procedure ID (%d) for successfull outcome message\n", (int)successfullOutcome_p->procedureCode); return -1; } message_string_size = strlen(message_string); message_p = itti_alloc_new_message_sized(TASK_S1AP, message_id, message_string_size + sizeof (IttiMsgText)); message_p->ittiMsg.s1ap_s1_setup_log.size = message_string_size; memcpy(&message_p->ittiMsg.s1ap_s1_setup_log.text, message_string, message_string_size); itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p); free(message_string); return ret; }
static int s1ap_eNB_decode_initiating_message(s1ap_message *message, S1ap_InitiatingMessage_t *initiating_p) { int ret = -1; MessageDef *message_p; char *message_string = NULL; size_t message_string_size; MessagesIds message_id; DevAssert(initiating_p != NULL); message_string = calloc(10000, sizeof(char)); s1ap_string_total_size = 0; message->procedureCode = initiating_p->procedureCode; message->criticality = initiating_p->criticality; switch(initiating_p->procedureCode) { case S1ap_ProcedureCode_id_downlinkNASTransport: ret = s1ap_decode_s1ap_downlinknastransporties( &message->msg.s1ap_DownlinkNASTransportIEs, &initiating_p->value); s1ap_xer_print_s1ap_downlinknastransport(s1ap_xer__print2sp, message_string, message); message_id = S1AP_DOWNLINK_NAS_LOG; message_string_size = strlen(message_string); message_p = itti_alloc_new_message_sized(TASK_S1AP, message_id, message_string_size + sizeof (IttiMsgText)); message_p->ittiMsg.s1ap_downlink_nas_log.size = message_string_size; memcpy(&message_p->ittiMsg.s1ap_downlink_nas_log.text, message_string, message_string_size); itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p); free(message_string); break; case S1ap_ProcedureCode_id_InitialContextSetup: ret = s1ap_decode_s1ap_initialcontextsetuprequesties( &message->msg.s1ap_InitialContextSetupRequestIEs, &initiating_p->value); s1ap_xer_print_s1ap_initialcontextsetuprequest(s1ap_xer__print2sp, message_string, message); message_id = S1AP_INITIAL_CONTEXT_SETUP_LOG; message_string_size = strlen(message_string); message_p = itti_alloc_new_message_sized(TASK_S1AP, message_id, message_string_size + sizeof (IttiMsgText)); message_p->ittiMsg.s1ap_initial_context_setup_log.size = message_string_size; memcpy(&message_p->ittiMsg.s1ap_initial_context_setup_log.text, message_string, message_string_size); itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p); free(message_string); break; case S1ap_ProcedureCode_id_UEContextRelease: ret = s1ap_decode_s1ap_uecontextreleasecommandies( &message->msg.s1ap_UEContextReleaseCommandIEs, &initiating_p->value); s1ap_xer_print_s1ap_uecontextreleasecommand(s1ap_xer__print2sp, message_string, message); message_id = S1AP_UE_CONTEXT_RELEASE_COMMAND_LOG; message_string_size = strlen(message_string); message_p = itti_alloc_new_message_sized(TASK_S1AP, message_id, message_string_size + sizeof (IttiMsgText)); message_p->ittiMsg.s1ap_ue_context_release_command_log.size = message_string_size; memcpy(&message_p->ittiMsg.s1ap_ue_context_release_command_log.text, message_string, message_string_size); itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p); free(message_string); break; default: S1AP_ERROR("Unknown procedure ID (%d) for initiating message\n", (int)initiating_p->procedureCode); AssertFatal( 0 , "Unknown procedure ID (%d) for initiating message\n", (int)initiating_p->procedureCode); return -1; } return ret; }
static inline int s1ap_eNB_encode_initiating(s1ap_message *s1ap_message_p, uint8_t **buffer, uint32_t *len) { int ret = -1; MessageDef *message_p; char *message_string = NULL; size_t message_string_size; MessagesIds message_id; DevAssert(s1ap_message_p != NULL); message_string = calloc(10000, sizeof(char)); s1ap_string_total_size = 0; switch(s1ap_message_p->procedureCode) { case S1ap_ProcedureCode_id_S1Setup: ret = s1ap_eNB_encode_s1_setup_request( &s1ap_message_p->msg.s1ap_S1SetupRequestIEs, buffer, len); s1ap_xer_print_s1ap_s1setuprequest(s1ap_xer__print2sp, message_string, s1ap_message_p); message_id = S1AP_S1_SETUP_LOG; break; case S1ap_ProcedureCode_id_uplinkNASTransport: ret = s1ap_eNB_encode_uplink_nas_transport( &s1ap_message_p->msg.s1ap_UplinkNASTransportIEs, buffer, len); s1ap_xer_print_s1ap_uplinknastransport(s1ap_xer__print2sp, message_string, s1ap_message_p); message_id = S1AP_UPLINK_NAS_LOG; break; case S1ap_ProcedureCode_id_UECapabilityInfoIndication: ret = s1ap_eNB_encode_ue_capability_info_indication( &s1ap_message_p->msg.s1ap_UECapabilityInfoIndicationIEs, buffer, len); s1ap_xer_print_s1ap_uecapabilityinfoindication(s1ap_xer__print2sp, message_string, s1ap_message_p); message_id = S1AP_UE_CAPABILITY_IND_LOG; break; case S1ap_ProcedureCode_id_initialUEMessage: ret = s1ap_eNB_encode_initial_ue_message( &s1ap_message_p->msg.s1ap_InitialUEMessageIEs, buffer, len); s1ap_xer_print_s1ap_initialuemessage(s1ap_xer__print2sp, message_string, s1ap_message_p); message_id = S1AP_INITIAL_UE_MESSAGE_LOG; break; case S1ap_ProcedureCode_id_NASNonDeliveryIndication: ret = s1ap_eNB_encode_nas_non_delivery( &s1ap_message_p->msg.s1ap_NASNonDeliveryIndication_IEs, buffer, len); s1ap_xer_print_s1ap_nasnondeliveryindication_(s1ap_xer__print2sp, message_string, s1ap_message_p); message_id = S1AP_NAS_NON_DELIVERY_IND_LOG; break; default: S1AP_DEBUG("Unknown procedure ID (%d) for initiating message\n", (int)s1ap_message_p->procedureCode); return ret; break; } message_string_size = strlen(message_string); message_p = itti_alloc_new_message_sized(TASK_S1AP, message_id, message_string_size + sizeof (IttiMsgText)); message_p->ittiMsg.s1ap_s1_setup_log.size = message_string_size; memcpy(&message_p->ittiMsg.s1ap_s1_setup_log.text, message_string, message_string_size); itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p); free(message_string); return ret; }
//----------------------------------------------------------------------------- void rlc_am_send_sdu ( const protocol_ctxt_t* const ctxt_pP, rlc_am_entity_t * const rlc_pP) { # if TRACE_RLC_UM_PDU char message_string[7000]; size_t message_string_size = 0; #if ENABLE_ITTI MessageDef *msg_p; #endif int octet_index, index; #endif if ((rlc_pP->output_sdu_in_construction)) { LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[SEND_SDU] %d bytes sdu %p\n", PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP), rlc_pP->output_sdu_size_to_write, rlc_pP->output_sdu_in_construction); if (rlc_pP->output_sdu_size_to_write > 0) { rlc_pP->stat_rx_pdcp_sdu += 1; rlc_pP->stat_rx_pdcp_bytes += rlc_pP->output_sdu_size_to_write; #if TEST_RLC_AM rlc_am_v9_3_0_test_data_ind (rlc_pP->module_id, rlc_pP->rb_id, rlc_pP->output_sdu_size_to_write, rlc_pP->output_sdu_in_construction); #else # if TRACE_RLC_AM_PDU message_string_size += sprintf(&message_string[message_string_size], "Bearer : %u\n", rlc_pP->rb_id); message_string_size += sprintf(&message_string[message_string_size], "SDU size : %u\n", rlc_pP->output_sdu_size_to_write); message_string_size += sprintf(&message_string[message_string_size], "\nPayload : \n"); message_string_size += sprintf(&message_string[message_string_size], "------+-------------------------------------------------|\n"); message_string_size += sprintf(&message_string[message_string_size], " | 0 1 2 3 4 5 6 7 8 9 a b c d e f |\n"); message_string_size += sprintf(&message_string[message_string_size], "------+-------------------------------------------------|\n"); for (octet_index = 0; octet_index < rlc_pP->output_sdu_size_to_write; octet_index++) { if ((octet_index % 16) == 0) { if (octet_index != 0) { message_string_size += sprintf(&message_string[message_string_size], " |\n"); } message_string_size += sprintf(&message_string[message_string_size], " %04d |", octet_index); } /* * Print every single octet in hexadecimal form */ message_string_size += sprintf(&message_string[message_string_size], " %02x", rlc_pP->output_sdu_in_construction->data[octet_index]); /* * Align newline and pipes according to the octets in groups of 2 */ } /* * Append enough spaces and put final pipe */ for (index = octet_index; index < 16; ++index) { message_string_size += sprintf(&message_string[message_string_size], " "); } message_string_size += sprintf(&message_string[message_string_size], " |\n"); # if ENABLE_ITTI msg_p = itti_alloc_new_message_sized (ctxt_pP->enb_flag > 0 ? TASK_RLC_ENB:TASK_RLC_UE , RLC_AM_SDU_IND, message_string_size + sizeof (IttiMsgText)); msg_p->ittiMsg.rlc_am_sdu_ind.size = message_string_size; memcpy(&msg_p->ittiMsg.rlc_am_sdu_ind.text, message_string, message_string_size); itti_send_msg_to_task(TASK_UNKNOWN, ctxt_pP->instance, msg_p); # else LOG_T(RLC, "%s", message_string); # endif # endif #if !ENABLE_ITTI RLC_AM_MUTEX_UNLOCK(&rlc_pP->lock_input_sdus); #endif MSC_LOG_TX_MESSAGE( (ctxt_pP->enb_flag == ENB_FLAG_YES) ? MSC_RLC_ENB:MSC_RLC_UE, (ctxt_pP->enb_flag == ENB_FLAG_YES) ? MSC_PDCP_ENB:MSC_PDCP_UE, (const char*)(rlc_pP->output_sdu_in_construction->data), rlc_pP->output_sdu_size_to_write, MSC_AS_TIME_FMT" "PROTOCOL_RLC_AM_MSC_FMT" DATA-IND size %u", MSC_AS_TIME_ARGS(ctxt_pP), PROTOCOL_RLC_AM_MSC_ARGS(ctxt_pP,rlc_pP), rlc_pP->output_sdu_size_to_write ); rlc_data_ind (ctxt_pP, BOOL_NOT(rlc_pP->is_data_plane), MBMS_FLAG_NO, rlc_pP->rb_id, rlc_pP->output_sdu_size_to_write, rlc_pP->output_sdu_in_construction); #if !ENABLE_ITTI RLC_AM_MUTEX_LOCK(&rlc_pP->lock_input_sdus, ctxt_pP, rlc_pP); #endif #endif rlc_pP->output_sdu_in_construction = NULL; } else { LOG_E(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[SEND_SDU] ERROR SIZE <= 0 ... DO NOTHING, SET SDU SIZE TO 0\n", PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP)); //msg("[RLC_AM][MOD %d] Freeing mem_block ...\n", rlc_pP->module_id); //free_mem_block (rlc_pP->output_sdu_in_construction); AssertFatal(3==4, PROTOCOL_RLC_AM_CTXT_FMT" SEND SDU REQUESTED %d bytes", PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP), rlc_pP->output_sdu_size_to_write); } rlc_pP->output_sdu_size_to_write = 0; } }
//log record, format, and print: executed in the main thread (mt) void logRecord_mt(const char *file, const char *func, int line, int comp, int level, const char *format, ...) { int len = 0; va_list args; log_component_t *c; char *log_start; char *log_end; /* The main difference with the version above is the use of this local log_buffer. * The other difference is the return value of snprintf which was not used * correctly. It was not a big problem because in practice MAX_LOG_TOTAL is * big enough so that the buffer is never full. */ char log_buffer[MAX_LOG_TOTAL]; /* for no gcc warnings */ (void)log_start; (void)log_end; c = &g_log->log_component[comp]; // do not apply filtering for LOG_F // only log messages which are enabled and are below the global log level and component's level threshold if ((level != LOG_FILE) && ((level > c->level) || (level > g_log->level))) { /* if ((level != LOG_FILE) && ((level > c->level) || (level > g_log->level) || ( c->level > g_log->level))) { */ return; } VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_LOG_RECORD, VCD_FUNCTION_IN); va_start(args, format); // adjust syslog level for TRACE messages if (g_log->syslog) { if (g_log->level > LOG_DEBUG) { g_log->level = LOG_DEBUG; } } // make sure that for log trace the extra info is only printed once, reset when the level changes if ((level == LOG_FILE) || (c->flag == LOG_NONE) || (level == LOG_TRACE)) { log_start = log_buffer; len = vsnprintf(log_buffer, MAX_LOG_TOTAL, format, args); if (len > MAX_LOG_TOTAL) len = MAX_LOG_TOTAL; log_end = log_buffer + len; } else { if ( (g_log->flag & FLAG_COLOR) || (c->flag & FLAG_COLOR) ) { len += snprintf(&log_buffer[len], MAX_LOG_TOTAL - len, "%s", log_level_highlight_start[level]); if (len > MAX_LOG_TOTAL) len = MAX_LOG_TOTAL; } log_start = log_buffer + len; if ( (g_log->flag & FLAG_COMP) || (c->flag & FLAG_COMP) ) { len += snprintf(&log_buffer[len], MAX_LOG_TOTAL - len, "[%s]", g_log->log_component[comp].name); if (len > MAX_LOG_TOTAL) len = MAX_LOG_TOTAL; } if ( (g_log->flag & FLAG_LEVEL) || (c->flag & FLAG_LEVEL) ) { len += snprintf(&log_buffer[len], MAX_LOG_TOTAL - len, "[%s]", g_log->level2string[level]); if (len > MAX_LOG_TOTAL) len = MAX_LOG_TOTAL; } if ( (g_log->flag & FLAG_THREAD) || (c->flag & FLAG_THREAD) ) { # define THREAD_NAME_LEN 128 char threadname[THREAD_NAME_LEN]; if (pthread_getname_np(pthread_self(), threadname, THREAD_NAME_LEN) != 0) { perror("pthread_getname_np : "); } else { len += snprintf(&log_buffer[len], MAX_LOG_TOTAL - len, "[%s]", threadname); if (len > MAX_LOG_TOTAL) len = MAX_LOG_TOTAL; } # undef THREAD_NAME_LEN } if ( (g_log->flag & FLAG_FUNCT) || (c->flag & FLAG_FUNCT) ) { len += snprintf(&log_buffer[len], MAX_LOG_TOTAL - len, "[%s] ", func); if (len > MAX_LOG_TOTAL) len = MAX_LOG_TOTAL; } if ( (g_log->flag & FLAG_FILE_LINE) || (c->flag & FLAG_FILE_LINE) ) { len += snprintf(&log_buffer[len], MAX_LOG_TOTAL - len, "[%s:%d]", file, line); if (len > MAX_LOG_TOTAL) len = MAX_LOG_TOTAL; } len += vsnprintf(&log_buffer[len], MAX_LOG_TOTAL - len, format, args); if (len > MAX_LOG_TOTAL) len = MAX_LOG_TOTAL; log_end = log_buffer + len; if ( (g_log->flag & FLAG_COLOR) || (c->flag & FLAG_COLOR) ) { len += snprintf(&log_buffer[len], MAX_LOG_TOTAL - len, "%s", log_level_highlight_end[level]); if (len > MAX_LOG_TOTAL) len = MAX_LOG_TOTAL; } } va_end(args); // OAI printf compatibility if ((g_log->onlinelog == 1) && (level != LOG_FILE)) #ifdef RTAI if (len > MAX_LOG_TOTAL) { rt_printk ("[OPENAIR] FIFO_PRINTF WROTE OUTSIDE ITS MEMORY BOUNDARY : ERRORS WILL OCCUR\n"); } if (len > 0) { rtf_put (FIFO_PRINTF_NO, log_buffer, len); } #else fwrite(log_buffer, len, 1, stdout); #endif #ifndef RTAI if (g_log->syslog) { syslog(g_log->level, "%s", log_buffer); } if (g_log->filelog) { if (write(gfd, log_buffer, len) < len) { // TODO assert ? } } if ((g_log->log_component[comp].filelog) && (level == LOG_FILE)) { if (write(g_log->log_component[comp].fd, log_buffer, len) < len) { // TODO assert ? } } #else // online print messges if ((g_log->log_component[comp].filelog) && (level == LOG_FILE)) { printf(log_buffer); } #endif #if defined(ENABLE_ITTI) if (level <= LOG_DEBUG) { task_id_t origin_task_id = TASK_UNKNOWN; MessagesIds messages_id; MessageDef *message_p; size_t message_string_size; char *message_msg_p; message_string_size = log_end - log_start; #if !defined(DISABLE_ITTI_DETECT_SUB_TASK_ID) /* Try to identify sub task ID from log information (comp, log_instance_type) */ switch (comp) { case PHY: switch (log_instance_type) { case LOG_INSTANCE_ENB: origin_task_id = TASK_PHY_ENB; break; case LOG_INSTANCE_UE: origin_task_id = TASK_PHY_UE; break; default: break; } break; case MAC: switch (log_instance_type) { case LOG_INSTANCE_ENB: origin_task_id = TASK_MAC_ENB; break; case LOG_INSTANCE_UE: origin_task_id = TASK_MAC_UE; default: break; } break; case RLC: switch (log_instance_type) { case LOG_INSTANCE_ENB: origin_task_id = TASK_RLC_ENB; break; case LOG_INSTANCE_UE: origin_task_id = TASK_RLC_UE; default: break; } break; case PDCP: switch (log_instance_type) { case LOG_INSTANCE_ENB: origin_task_id = TASK_PDCP_ENB; break; case LOG_INSTANCE_UE: origin_task_id = TASK_PDCP_UE; default: break; } break; default: break; } #endif switch (level) { case LOG_EMERG: case LOG_ALERT: case LOG_CRIT: case LOG_ERR: messages_id = ERROR_LOG; break; case LOG_WARNING: messages_id = WARNING_LOG; break; case LOG_NOTICE: messages_id = NOTICE_LOG; break; case LOG_INFO: messages_id = INFO_LOG; break; default: messages_id = DEBUG_LOG; break; } message_p = itti_alloc_new_message_sized(origin_task_id, messages_id, message_string_size); switch (level) { case LOG_EMERG: case LOG_ALERT: case LOG_CRIT: case LOG_ERR: message_msg_p = (char *) &message_p->ittiMsg.error_log; break; case LOG_WARNING: message_msg_p = (char *) &message_p->ittiMsg.warning_log; break; case LOG_NOTICE: message_msg_p = (char *) &message_p->ittiMsg.notice_log; break; case LOG_INFO: message_msg_p = (char *) &message_p->ittiMsg.info_log; break; default: message_msg_p = (char *) &message_p->ittiMsg.debug_log; break; } memcpy(message_msg_p, log_start, message_string_size); itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p); } #endif VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_LOG_RECORD, VCD_FUNCTION_OUT); }