uint32_t service_id; /**< service ID */
uint8_t status; /**< reponse status */
uint8_t overflow; /**< overflow status */
+ uint32_t overflow_counter; /**< overflow counter */
} PACKED DltServiceMessageBufferOverflowResponse;
typedef struct
uint32_t dlt_ll_ts_num_entries; /**< Number of used contexts */
int8_t overflow; /**< Overflow marker, set to 1 on overflow, 0 otherwise */
+ uint32_t overflow_counter; /**< Counts the number of lost messages */
char *application_description; /**< description of application */
int dlt_daemon_process_user_message_overflow(DltDaemon *daemon, DltDaemonLocal *daemon_local, int verbose)
{
int j, sent;
+ DltUserControlMsgBufferOverflow *userpayload;
PRINT_FUNCTION_VERBOSE(verbose);
return -1;
}
+ if (daemon_local->receiver.bytesRcvd < (int32_t)(sizeof(DltUserHeader)+sizeof(DltUserControlMsgBufferOverflow)))
+ {
+ /* Not enough bytes received */
+ return -1;
+ }
+
+ /* get the payload of the user message */
+ userpayload = (DltUserControlMsgBufferOverflow*) (daemon_local->receiver.buf+sizeof(DltUserHeader));
+
/* Store in daemon, that a message buffer overflow has occured */
daemon->message_buffer_overflow = DLT_MESSAGE_BUFFER_OVERFLOW;
/* except the listener and ourselves */
if ((j != daemon_local->fp) && (j != daemon_local->sock))
{
- dlt_daemon_control_message_buffer_overflow(j, daemon, verbose);
+ dlt_daemon_control_message_buffer_overflow(j, daemon, userpayload->overflow_counter,userpayload->apid,verbose);
sent=1;
/* Reset overflow state */
daemon->message_buffer_overflow = DLT_MESSAGE_BUFFER_NO_OVERFLOW;
/* message was not sent, so store it in ringbuffer */
if (sent==0)
{
- dlt_daemon_control_message_buffer_overflow(DLT_DAEMON_STORE_TO_BUFFER, daemon, verbose);
+ if(dlt_daemon_control_message_buffer_overflow(DLT_DAEMON_STORE_TO_BUFFER, daemon, userpayload->overflow_counter,
+ userpayload->apid,verbose))
+ {
+ /* there was an error when storing message */
+ /* add the counter of lost messages to the daemon counter */
+ daemon->overflow_counter+=userpayload->overflow_counter;
+ }
}
/* keep not read data in buffer */
- if (dlt_receiver_remove(&(daemon_local->receiver),sizeof(DltUserHeader))==-1)
+ if (dlt_receiver_remove(&(daemon_local->receiver),sizeof(DltUserHeader)+sizeof(DltUserControlMsgBufferOverflow))==-1)
{
dlt_log(LOG_ERR,"Can't remove bytes from receiver for user message overflow\n");
return -1;
return 0;
}
+int dlt_daemon_send_message_overflow(DltDaemon *daemon, DltDaemonLocal *daemon_local, int verbose)
+{
+ int j, sent;
+
+ PRINT_FUNCTION_VERBOSE(verbose);
+
+ if ((daemon==0) || (daemon_local==0))
+ {
+ dlt_log(LOG_ERR, "Invalid function parameters used for function dlt_daemon_process_user_message_overflow()\n");
+ return -1;
+ }
+
+ /* Store in daemon, that a message buffer overflow has occured */
+ daemon->message_buffer_overflow = DLT_MESSAGE_BUFFER_OVERFLOW;
+
+ /* look if TCP connection to client is available */
+ sent = 0;
+
+ for (j = 0; j <= daemon_local->fdmax; j++)
+ {
+ /* send to everyone! */
+ if (FD_ISSET(j, &(daemon_local->master)))
+ {
+ /* except the listener and ourselves */
+ if ((j != daemon_local->fp) && (j != daemon_local->sock))
+ {
+ dlt_daemon_control_message_buffer_overflow(j, daemon,daemon->overflow_counter,"", verbose);
+ sent=1;
+ /* Reset overflow state */
+ daemon->message_buffer_overflow = DLT_MESSAGE_BUFFER_NO_OVERFLOW;
+ } /* if */
+ } /* if */
+ } /* for */
+
+ /* message was not sent, so store it in ringbuffer */
+ if (sent==0)
+ {
+ return -1;
+ }
+
+ return 0;
+}
+
int dlt_daemon_process_user_message_register_application(DltDaemon *daemon, DltDaemonLocal *daemon_local, int verbose)
{
uint32_t len=0;
sent = 1;
}
+ /* check if overflow occurred */
+ if(daemon->overflow_counter)
+ {
+ if(dlt_daemon_send_message_overflow(daemon,daemon_local,verbose)==0)
+ {
+ sprintf(str,"%u messages discarded!\n",daemon->overflow_counter);
+ dlt_log(LOG_ERR, str);
+ daemon->overflow_counter=0;
+ }
+ }
+
/* look if TCP connection to client is available */
for (j = 0;((daemon->mode == DLT_USER_MODE_EXTERNAL) || (daemon->mode == DLT_USER_MODE_BOTH)) && (j <= daemon_local->fdmax); j++)
{
0, 0
)<0)
{
- dlt_log(LOG_ERR,"Storage of message in history buffer failed! Message discarded.\n");
+ if(daemon->overflow_counter==0)
+ dlt_log(LOG_ERR,"Buffer full! Messages will be discarded.\n");
+ daemon->overflow_counter+=1;
}
DLT_DAEMON_SEM_FREE();
}
int dlt_daemon_process_user_messages(DltDaemon *daemon, DltDaemonLocal *daemon_local, int verbose);\r
\r
int dlt_daemon_process_user_message_overflow(DltDaemon *daemon, DltDaemonLocal *daemon_local, int verbose);\r
+int dlt_daemon_send_message_overflow(DltDaemon *daemon, DltDaemonLocal *daemon_local, int verbose);\r
int dlt_daemon_process_user_message_register_application(DltDaemon *daemon, DltDaemonLocal *daemon_local, int verbose);\r
int dlt_daemon_process_user_message_unregister_application(DltDaemon *daemon, DltDaemonLocal *daemon_local, int verbose);\r
int dlt_daemon_process_user_message_register_context(DltDaemon *daemon, DltDaemonLocal *daemon_local, int verbose);\r
daemon->default_trace_status = DLT_DAEMON_INITIAL_TRACE_STATUS ;
daemon->message_buffer_overflow = DLT_MESSAGE_BUFFER_NO_OVERFLOW;
+ daemon->overflow_counter = 0;
daemon->runtime_context_cfg_loaded = 0;
}
case DLT_SERVICE_ID_MESSAGE_BUFFER_OVERFLOW:
{
- dlt_daemon_control_message_buffer_overflow(sock, daemon, verbose);
+ dlt_daemon_control_message_buffer_overflow(sock, daemon, daemon->overflow_counter,"",verbose);
break;
}
default:
dlt_message_free(&resp,0);
}
-void dlt_daemon_control_message_buffer_overflow(int sock, DltDaemon *daemon, int verbose)
+int dlt_daemon_control_message_buffer_overflow(int sock, DltDaemon *daemon, unsigned int overflow_counter,char* apid, int verbose)
{
DltMessage msg;
DltServiceMessageBufferOverflowResponse *resp;
if (daemon==0)
{
- return;
+ return -1;
}
/* initialise new message */
if (dlt_message_init(&msg,0)==-1)
{
dlt_daemon_control_service_response(sock, daemon, DLT_SERVICE_ID_MESSAGE_BUFFER_OVERFLOW, DLT_SERVICE_RESPONSE_ERROR, verbose);
- return;
+ return -1;
}
/* prepare payload of data */
{
dlt_daemon_control_service_response(sock, daemon, DLT_SERVICE_ID_MESSAGE_BUFFER_OVERFLOW, DLT_SERVICE_RESPONSE_ERROR, verbose);
}
- return;
+ return -1;
}
resp = (DltServiceMessageBufferOverflowResponse*) msg.databuffer;
resp->service_id = DLT_SERVICE_ID_MESSAGE_BUFFER_OVERFLOW;
resp->status = DLT_SERVICE_RESPONSE_OK;
resp->overflow = daemon->message_buffer_overflow;
+ resp->overflow_counter = overflow_counter;
/* send message */
- dlt_daemon_control_send_control_message(sock,daemon,&msg,"","", verbose);
+ if(dlt_daemon_control_send_control_message(sock,daemon,&msg,apid,"", verbose))
+ {
+ dlt_message_free(&msg,0);
+ return -1;
+ }
/* free message */
dlt_message_free(&msg,0);
+
+ return 0;
}
void dlt_daemon_control_service_response( int sock, DltDaemon *daemon, uint32_t service_id, int8_t status , int verbose)
dlt_message_free(&msg,0);
}
-void dlt_daemon_control_send_control_message( int sock, DltDaemon *daemon, DltMessage *msg, char* appid, char* ctid, int verbose)
+int dlt_daemon_control_send_control_message( int sock, DltDaemon *daemon, DltMessage *msg, char* appid, char* ctid, int verbose)
{
ssize_t ret;
int32_t len;
if ((daemon==0) || (msg==0) || (appid==0) || (ctid==0))
{
- return;
+ return -1;
}
/* prepare storage header */
if (dlt_set_storageheader(msg->storageheader,daemon->ecuid)==-1)
{
- return;
+ return -1;
}
/* prepare standard header */
if (len>UINT16_MAX)
{
dlt_log(LOG_CRIT,"Huge control message discarded!\n");
- return;
+ return -1;
}
msg->standardheader->len = DLT_HTOBE_16(((uint16_t)len));
{
dlt_log(LOG_CRIT,"dlt_daemon_control_send_control_message: write dltSerialHeader failed\n");
DLT_DAEMON_SEM_FREE();
- return;
+ return -1;
}
}
{
dlt_log(LOG_CRIT,"dlt_daemon_control_send_control_message: write msg->headerbuffer failed\n");
DLT_DAEMON_SEM_FREE();
- return;
+ return -1;
}
ret=write(sock, msg->databuffer,msg->datasize);
if (0 > ret)
{
dlt_log(LOG_CRIT,"dlt_daemon_control_send_control_message: write msg->databuffer failed\n");
DLT_DAEMON_SEM_FREE();
- return;
+ return -1;
}
DLT_DAEMON_SEM_FREE();
{
DLT_DAEMON_SEM_FREE();
dlt_log(LOG_ERR,"Storage of message in history buffer failed! Message discarded.\n");
- return;
+ return -1;
}
DLT_DAEMON_SEM_FREE();
}
+ return 0;
}
void dlt_daemon_control_reset_to_factory_default(DltDaemon *daemon,const char *filename, const char *filename1, int verbose)
int8_t default_log_level; /**< Default log level (of daemon) */\r
int8_t default_trace_status; /**< Default trace status (of daemon) */\r
int message_buffer_overflow; /**< Set to one, if buffer overflow has occured, zero otherwise */\r
+ unsigned int overflow_counter; /**< counts the number of lost messages. */\r
int runtime_context_cfg_loaded; /**< Set to one, if runtime context configuration has been loaded, zero otherwise */\r
char ecuid[DLT_ID_SIZE]; /**< ECU ID of daemon */\r
int sendserialheader; /**< 1: send serial header; 0 don't send serial header */\r
* @param appid pointer to application id to be used in response message\r
* @param contid pointer to context id to be used in response message\r
* @param verbose if set to true verbose information is printed out.\r
+ * @return -1 if there is an error or buffer is full\r
*/\r
-void dlt_daemon_control_send_control_message(int sock, DltDaemon *daemon, DltMessage *msg, char* appid, char* contid, int verbose);\r
+int dlt_daemon_control_send_control_message(int sock, DltDaemon *daemon, DltMessage *msg, char* appid, char* contid, int verbose);\r
\r
/**\r
* Process and generate response to received sw injection control message\r
* @param sock connection handle used for sending response\r
* @param daemon pointer to dlt daemon structure\r
* @param verbose if set to true verbose information is printed out.\r
+ * @return -1 if there is an error or buffer overflow, else 0\r
*/\r
-void dlt_daemon_control_message_buffer_overflow(int sock, DltDaemon *daemon, int verbose);\r
+int dlt_daemon_control_message_buffer_overflow(int sock, DltDaemon *daemon, unsigned int overflow_counter,char* apid, int verbose);\r
/**\r
* Process reset to factory default control message\r
* @param daemon pointer to dlt daemon structure\r
dlt_user.dlt_is_file = 0;
dlt_user.overflow = 0;
+ dlt_user.overflow_counter = 0;
#ifdef DLT_SHM_ENABLE
memset(&(dlt_user.dlt_shm),0,sizeof(DltShm));
#endif
/* Reattach to daemon if neccesary */
dlt_user_log_reattach_to_daemon();
- if (dlt_user.overflow)
+ if (dlt_user.overflow_counter)
{
if (dlt_user_log_send_overflow()==0)
{
- dlt_user.overflow=0;
- }
+ sprintf(str,"Buffer full! %u messages discarded!\n",dlt_user.overflow_counter);
+ dlt_log(LOG_ERR, str);
+ dlt_user.overflow_counter=0; }
}
/* log to FIFO */
(unsigned char *)&(userheader), sizeof(DltUserHeader),
msgdata, size, 0, 0)==-1)
{
- dlt_log(LOG_ERR,"Storing message to history buffer failed! Message discarded.\n");
+ if(dlt_user.overflow_counter==0)
+ {
+ dlt_log(LOG_ERR,"Buffer full! First message discarded!\n");
+ }
}
DLT_SEM_FREE();
if(dlt_user_queue_resend() < 0 && dlt_user.dlt_log_handle >= 0)
{
- dlt_log(LOG_WARNING, "dlt_forward_msg: Failed to queue resending.\n");
+ ;//dlt_log(LOG_WARNING, "dlt_forward_msg: Failed to queue resending.\n");
}
}
case DLT_RETURN_PIPE_FULL:
{
/* data could not be written */
- dlt_user.overflow = 1;
+ dlt_user.overflow_counter += 1;
return -1;
}
case DLT_RETURN_PIPE_ERROR:
{
// Requeue if still not empty
if ( dlt_user_queue_resend() < 0 )
- dlt_log(LOG_WARNING, "Failed to queue resending in dlt_user_trace_network_segmented_thread.\n");
+ {
+ ;//dlt_log(LOG_WARNING, "Failed to queue resending in dlt_user_trace_network_segmented_thread.\n");
+ }
}
free(data);
continue;
int dlt_user_queue_resend(void)
{
+ static unsigned int dlt_user_queue_resend_error_counter = 0;
+
if(dlt_user.dlt_log_handle < 0)
{
// Fail silenty. FIFO is not open yet
/* Open queue if it is not open */
if(dlt_init_message_queue() < 0)
{
- dlt_log(LOG_ERR, "NWTSegmented: Could not open queue.\n");
- free(resend_data);
+ if(!dlt_user_queue_resend_error_counter)
+ {
+ // log error only when problem occurred first time
+ dlt_log(LOG_ERR, "NWTSegmented: Could not open queue.\n");
+ }
+ dlt_user_queue_resend_error_counter++;
+ free(resend_data);
return -1;
}
if(mq_send(dlt_user.dlt_segmented_queue_write_handle, (char *)&resend_data, sizeof(s_segmented_data *), 1) < 0)
{
- char str[255];
- snprintf(str,254,"Could not request resending.: %s \n",strerror(errno));
- dlt_log(LOG_CRIT, str);
+ if(!dlt_user_queue_resend_error_counter)
+ {
+ // log error only when problem occurred first time
+ char str[255];
+ snprintf(str,254,"Could not request resending.: %s \n",strerror(errno));
+ dlt_log(LOG_CRIT, str);
+ }
+ dlt_user_queue_resend_error_counter++;
free(resend_data);
return -1;
}
+
+ dlt_user_queue_resend_error_counter = 0;
+
//thread_data will be freed by the receiver function
//coverity[leaked_storage]
return 0;
/* Reattach to daemon if neccesary */
dlt_user_log_reattach_to_daemon();
- if (dlt_user.overflow)
+ if (dlt_user.overflow_counter)
{
if (dlt_user_log_send_overflow()==0)
{
- dlt_user.overflow=0;
+ sprintf(str,"%u messages discarded!\n",dlt_user.overflow_counter);
+ dlt_log(LOG_ERR, str);
+ dlt_user.overflow_counter=0;
}
}
msg.headerbuffer+sizeof(DltStorageHeader), msg.headersize-sizeof(DltStorageHeader),
log->buffer, log->size)==-1)
{
- dlt_log(LOG_ERR,"Storing message to history buffer failed! Message discarded.\n");
- ret = DLT_RETURN_BUFFER_FULL;
+ if(dlt_user.overflow_counter==0)
+ {
+
+ dlt_log(LOG_ERR,"Buffer full! Messages will be discarded.\n");
+ }
+ ret = DLT_RETURN_BUFFER_FULL;
}
DLT_SEM_FREE();
// Fail silenty if FIFO is not open
if(dlt_user_queue_resend() < 0 && dlt_user.dlt_log_handle >= 0)
{
- dlt_log(LOG_WARNING, "dlt_user_log_send_log: Failed to queue resending.\n");
+ ;//dlt_log(LOG_WARNING, "dlt_user_log_send_log: Failed to queue resending.\n");
}
}
case DLT_RETURN_BUFFER_FULL:
{
/* Buffer full */
+ dlt_user.overflow_counter += 1;
return DLT_RETURN_BUFFER_FULL;
}
case DLT_RETURN_PIPE_FULL:
{
/* data could not be written */
- dlt_user.overflow = 1;
return DLT_RETURN_PIPE_FULL;
}
case DLT_RETURN_PIPE_ERROR:
if(dlt_user_queue_resend() < 0 && dlt_user.dlt_log_handle >= 0)
{
- dlt_log(LOG_WARNING, "dlt_user_log_send_register_application: Failed to queue resending.\n");
+ ;//dlt_log(LOG_WARNING, "dlt_user_log_send_register_application: Failed to queue resending.\n");
}
}
if(dlt_user_queue_resend() < 0 && dlt_user.dlt_log_handle >= 0)
{
- dlt_log(LOG_WARNING, "dlt_user_log_send_register_context: Failed to queue resending.\n");
+ ;//dlt_log(LOG_WARNING, "dlt_user_log_send_register_context: Failed to queue resending.\n");
}
}
int dlt_user_log_send_overflow(void)
{
DltUserHeader userheader;
+ DltUserControlMsgBufferOverflow userpayload;
DltReturnValue ret;
/* set userheader */
return 0;
}
+ /* set user message parameters */
+ userpayload.overflow_counter = dlt_user.overflow_counter;
+ dlt_set_id(userpayload.apid,dlt_user.appID);
+
/* log to FIFO */
- ret=dlt_user_log_out2(dlt_user.dlt_log_handle, &(userheader), sizeof(DltUserHeader), 0, 0);
+ ret=dlt_user_log_out2(dlt_user.dlt_log_handle, &(userheader), sizeof(DltUserHeader),
+ &(userpayload), sizeof(DltUserControlMsgBufferOverflow));
return ((ret==DLT_RETURN_OK)?0:-1);
}
// try to increase size if possible
if(dlt_buffer_increase_size(buf)) {
/* increase size is not possible */
- dlt_log(LOG_ERR,"Buffer: Buffer is full\n");
+ //dlt_log(LOG_ERR,"Buffer: Buffer is full\n");
return -1; // ERROR
}
// update pointers
int8_t log_state; /**< the state to be used for logging state: 0 = off, 1 = external client connected */\r
} PACKED DltUserControlMsgLogState;\r
\r
+/**\r
+ * This is the internal message content to get the lnumber of lost messages reported to the daemon.\r
+ */\r
+typedef struct\r
+{\r
+ uint32_t overflow_counter; /**< counts the number of lost messages */\r
+ char apid[4]; /**< application which lost messages */\r
+} PACKED DltUserControlMsgBufferOverflow;\r
+\r
/**************************************************************************************************\r
* The folowing functions are used shared between the user lib and the daemon implementation\r
**************************************************************************************************/\r
projects / profile / ivi / dlt-daemon.git / commitdiff