-/*
- * Dlt- Diagnostic Log and Trace console apps
+/**
* @licence app begin@
+ * Copyright (C) 2012 BMW AG
+ *
+ * This file is part of GENIVI Project Dlt - Diagnostic Log and Trace console apps.
+ *
+ * Contributions are licensed to the GENIVI Alliance under one or more
+ * Contribution License Agreements.
+ *
+ * \copyright
+ * This Source Code Form is subject to the terms of the
+ * Mozilla Public License, v. 2.0. If a copy of the MPL was not distributed with
+ * this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
*
- * Copyright (C) 2011, BMW AG - Alexander Wenzel <alexander.wenzel@bmw.de>
- *
- * This program is free software; you can redistribute it and/or modify it under the terms of the
- * GNU Lesser General Public License, version 2.1, as published by the Free Software Foundation.
- * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
- * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
- * Public License, version 2.1, for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License, version 2.1, along
- * with this program; if not, see <http://www.gnu.org/licenses/lgpl-2.1.html>.
- *
- * Note that the copyright holders assume that the GNU Lesser General Public License, version 2.1, may
- * also be applicable to programs even in cases in which the program is not a library in the technical sense.
- *
- * Linking DLT statically or dynamically with other modules is making a combined work based on DLT. You may
- * license such other modules under the GNU Lesser General Public License, version 2.1. If you do not want to
- * license your linked modules under the GNU Lesser General Public License, version 2.1, you
- * may use the program under the following exception.
- *
- * As a special exception, the copyright holders of DLT give you permission to combine DLT
- * with software programs or libraries that are released under any license unless such a combination is not
- * permitted by the license of such a software program or library. You may copy and distribute such a
- * system following the terms of the GNU Lesser General Public License, version 2.1, including this
- * special exception, for DLT and the licenses of the other code concerned.
- *
- * Note that people who make modified versions of DLT are not obligated to grant this special exception
- * for their modified versions; it is their choice whether to do so. The GNU Lesser General Public License,
- * version 2.1, gives permission to release a modified version without this exception; this exception
- * also makes it possible to release a modified version which carries forward this exception.
+ * \author Alexander Wenzel <alexander.aw.wenzel@bmw.de> BMW 2011-2012
*
+ * \file dlt_common.c
+ * For further information see http://www.genivi.org/.
* @licence end@
*/
#include <stdlib.h> /* for malloc(), free() */
#include <string.h> /* for strlen(), memcmp(), memmove() */
#include <time.h> /* for localtime(), strftime() */
+#include <limits.h> /* for NAME_MAX */
#include "dlt_common.h"
#include "dlt_common_cfg.h"
/* internal logging parameters */
static int logging_mode = 0;
static int logging_level = 6;
-static char logging_filename[256] = "";
+static char logging_filename[NAME_MAX + 1] = "";
static FILE *logging_handle = 0;
char *message_type[] = {"log","app_trace","nw_trace","control","","","",""};
};
static char *return_type[] = {"ok","not_supported","error","","","","","","no_matching_context_id"};
+/* internal function definitions */
+int dlt_buffer_get(DltBuffer *buf,unsigned char *data, int max_size,int delete);
+int dlt_buffer_reset(DltBuffer *buf);
+int dlt_buffer_increase_size(DltBuffer *buf);
+int dlt_buffer_minimize_size(DltBuffer *buf);
+void dlt_buffer_write_block(DltBuffer *buf,int *write, const unsigned char *data,unsigned int size);
+void dlt_buffer_read_block(DltBuffer *buf,int *read,unsigned char *data,unsigned int size);
+
void dlt_print_hex(uint8_t *ptr,int size)
{
int num;
/* apid matches, now check for ctid */
if (ctid==0)
{
- /* check if empty ctid matches */
- if (memcmp(filter->ctid[num],"",DLT_ID_SIZE)==0)
+ /* check if empty ctid matches */
+ //if (memcmp(filter->ctid[num],"",DLT_ID_SIZE)==0)//coverity complains here about Out-of-bounds access.
+ char empty_ctid[DLT_ID_SIZE]="";
+ if (memcmp(filter->ctid[num],empty_ctid,DLT_ID_SIZE)==0)
{
return num;
}
msg->datasize = 0;
msg->databuffer = 0;
+ msg->databuffersize = 0;
msg->storageheader = 0;
msg->standardheader = 0;
if (msg->databuffer)
{
free(msg->databuffer);
+ msg->databuffer = 0;
+ msg->databuffersize = 0;
}
- msg->databuffer = 0;
return 0;
}
/* free last used memory for buffer */
if (msg->databuffer)
{
- free(msg->databuffer);
+ if (msg->datasize>msg->databuffersize){
+ free(msg->databuffer);
+ msg->databuffer=(uint8_t *)malloc(msg->datasize);
+ msg->databuffersize = msg->datasize;
+ }
+ }else{
+ /* get new memory for buffer */
+ msg->databuffer = (uint8_t *)malloc(msg->datasize);
+ msg->databuffersize = msg->datasize;
}
-
- /* get new memory for buffer */
- msg->databuffer = (uint8_t *)malloc(msg->datasize);
if (msg->databuffer == 0)
{
sprintf(str,"Cannot allocate memory for payload buffer of size %d!\n",msg->datasize);
else
{
/* go back to last file position */
- fseek(file->handle,file->file_position,SEEK_SET);
+ if (0 != fseek(file->handle,file->file_position,SEEK_SET))
+ return -1;
}
}
}
/* free last used memory for buffer */
- if (file->msg.databuffer)
+ if (file->msg.databuffer && (file->msg.databuffersize < file->msg.datasize))
{
free(file->msg.databuffer);
+ file->msg.databuffer=0;
}
- /* get new memory for buffer */
- file->msg.databuffer = (uint8_t *)malloc(file->msg.datasize);
+ if (file->msg.databuffer == 0){
+ /* get new memory for buffer */
+ file->msg.databuffer = (uint8_t *)malloc(file->msg.datasize);
+ file->msg.databuffersize = file->msg.datasize;
+ }
if (file->msg.databuffer == 0)
{
file->handle = fopen(filename,"rb");
if (file->handle == 0)
{
- sprintf(str,"File %s cannot be opened!\n",filename);
+ snprintf(str, DLT_COMMON_BUFFER_LENGTH - 1 ,"File %s cannot be opened!\n",filename);
+
dlt_log(LOG_ERR, str);
return -1;
}
- fseek(file->handle,0,SEEK_END);
+ if (0 != fseek(file->handle,0,SEEK_END))
+ {
+ sprintf(str,"dlt_file_open: Seek failed to 0,SEEK_END");
+ dlt_log(LOG_ERR, str);
+ return -1;
+ }
file->file_length = ftell(file->handle);
- fseek(file->handle,0,SEEK_SET);
+
+ if (0 != fseek(file->handle,0,SEEK_SET))
+ {
+ sprintf(str,"dlt_file_open: Seek failed to 0,SEEK_SET");
+ dlt_log(LOG_ERR, str);
+ return -1;
+ }
if (verbose)
{
}
/* set to end of last succesful read message, because of conflicting calls to dlt_file_read and dlt_file_message */
- fseek(file->handle,file->file_position,SEEK_SET);
+ if (0 != fseek(file->handle,file->file_position,SEEK_SET))
+ {
+ sprintf(str,"Seek failed to file_position %ld \n",file->file_position);
+ dlt_log(LOG_ERR, str);
+ return -1;
+ }
/* get file position at start of DLT message */
if (verbose)
if (dlt_file_read_header_extended(file, verbose)<0)
{
/* go back to last position in file */
- fseek(file->handle,file->file_position,SEEK_SET);
+ if (0 != fseek(file->handle,file->file_position,SEEK_SET))
+ {
+ sprintf(str,"Seek to last file pos failed!\n");
+ dlt_log(LOG_ERR, str);
+ }
return-1;
}
if (fseek(file->handle,file->msg.datasize,SEEK_CUR)!=0)
{
/* go back to last position in file */
- fseek(file->handle,file->file_position,SEEK_SET);
sprintf(str,"Seek failed to skip payload data of size %d!\n",file->msg.datasize);
dlt_log(LOG_ERR, str);
+
+ if (0 != fseek(file->handle,file->file_position,SEEK_SET))
+ {
+ sprintf(str,"Seek back also failed!\n");
+ dlt_log(LOG_ERR, str);
+ }
+
return -1;
}
}
/* skip additional header parameters and payload data */
if (fseek(file->handle,file->msg.headersize - sizeof(DltStorageHeader) - sizeof(DltStandardHeader) + file->msg.datasize,SEEK_CUR))
{
- /* go back to last position in file */
- fseek(file->handle,file->file_position,SEEK_SET);
+
sprintf(str,"Seek failed to skip extra header and payload data from file of size %d!\n",
file->msg.headersize - sizeof(DltStorageHeader) - sizeof(DltStandardHeader) + file->msg.datasize);
dlt_log(LOG_ERR, str);
+ /* go back to last position in file */
+ if (fseek(file->handle,file->file_position,SEEK_SET))
+ {
+ sprintf(str,"Seek back also failed!\n");
+ dlt_log(LOG_ERR, str);
+ }
return -1;
}
file->index = ptr;
}
- /* set to end of last succesful read message, because of conflicting calls to dlt_file_read and dlt_file_message */
- fseek(file->handle,file->file_position,SEEK_SET);
+ /* set to end of last successful read message, because of conflicting calls to dlt_file_read and dlt_file_message */
+ if (0 != fseek(file->handle,file->file_position,SEEK_SET))
+ return -1;
/* get file position at start of DLT message */
if (verbose)
if (dlt_file_read_header_raw(file,resync,verbose)<0)
{
/* go back to last position in file */
- fseek(file->handle,file->file_position,SEEK_SET);
+ if (0!= fseek(file->handle,file->file_position,SEEK_SET))
+ {
+ sprintf(str,"dlt_file_read_raw, fseek failed 1\n");
+ dlt_log(LOG_ERR, str);
+ }
return -1;
}
if (dlt_file_read_header_extended(file, verbose)<0)
{
/* go back to last position in file */
- fseek(file->handle,file->file_position,SEEK_SET);
+ if (0 != fseek(file->handle,file->file_position,SEEK_SET))
+ {
+ sprintf(str,"dlt_file_read_raw, fseek failed 2\n");
+ dlt_log(LOG_ERR, str);
+ }
return-1;
}
if (dlt_file_read_data(file,verbose)<0)
{
/* go back to last position in file */
- fseek(file->handle,file->file_position,SEEK_SET);
+ if (0 != fseek(file->handle,file->file_position,SEEK_SET))
+ {
+ sprintf(str,"dlt_file_read_raw, fseek failed 3\n");
+ dlt_log(LOG_ERR, str);
+ }
return-1;
}
void dlt_log_set_filename(const char *filename)
{
- strncpy(logging_filename,filename,sizeof(logging_filename));
+ strncpy(logging_filename,filename,NAME_MAX);
+
}
void dlt_log_init(int mode)
break;
case 2:
/* log to file */
- if(logging_handle)
+ if(logging_handle) {
fprintf(logging_handle,logfmtstring, s);
+ fflush(logging_handle);
+ }
break;
}
return -1;
}
+ if (size > receiver->bytesRcvd || size <= 0)
+ {
+ receiver->buf = receiver->buf + receiver->bytesRcvd;
+ receiver->bytesRcvd=0;
+ return -1;
+ }
+
receiver->bytesRcvd = receiver->bytesRcvd - size;
receiver->buf = receiver->buf + size;
(storageheader->pattern[3] == 1));
}
-int dlt_ringbuffer_init(DltRingBuffer *dltbuf, uint32_t size)
-{
-
- if (dltbuf==0)
- {
- return -1;
- }
- if (size<=sizeof(uint32_t))
- {
- return -1;
- }
- dltbuf->buffer=(char*)malloc(size);
- if (dltbuf->buffer==0)
- {
- return -1;
- }
- dltbuf->size=size;
- dltbuf->pos_write=0;
- dltbuf->pos_read=0;
- dltbuf->count=0;
- return 0;
-}
-int dlt_ringbuffer_free(DltRingBuffer *dltbuf)
-{
- if (dltbuf==0)
- {
- return -1;
- }
- if (dltbuf->buffer)
- {
- free(dltbuf->buffer);
- }
- dltbuf->buffer=0;
- dltbuf->size=0;
+int dlt_buffer_init_static_server(DltBuffer *buf, const unsigned char *ptr, uint32_t size)
+{
+ char str[256];
+ DltBufferHead *head;
- dltbuf->pos_write=0;
- dltbuf->pos_read=0;
+ // Init parameters
+ buf->shm = (unsigned char *)ptr;
+ buf->min_size = size;
+ buf->max_size = size;
+ buf->step_size = 0;
+
+ // Init pointers
+ head = (DltBufferHead*)buf->shm;
+ head->read = 0;
+ head->write = 0;
+ head->count = 0;
+ buf->mem = (unsigned char *)(buf->shm + sizeof(DltBufferHead));
+ buf->size = buf->min_size - sizeof(DltBufferHead);
- dltbuf->count=0;
+ // clear memory
+ memset(buf->mem,0,buf->size);
+
+ snprintf(str,sizeof(str),"Buffer: Size %d\n",buf->size);
+ dlt_log(LOG_INFO, str);
- return 0;
+ return 0; /* OK */
}
-int dlt_ringbuffer_put(DltRingBuffer *dltbuf, void *data, uint32_t size)
+int dlt_buffer_init_static_client(DltBuffer *buf, const unsigned char *ptr, uint32_t size)
{
- uint32_t sui, part1, part2;
+ char str[256];
- if (dltbuf==0)
- {
- return -1;
- }
-
- if (dltbuf->buffer==0)
- {
- return -1;
- }
-
- if (data==0)
- {
- return -1;
- }
-
- sui = sizeof(uint32_t);
-
- if ((size+sui)>dltbuf->size)
- {
- return -1;
- }
+ // Init parameters
+ buf->shm = (unsigned char *)ptr;
+ buf->min_size = size;
+ buf->max_size = size;
+ buf->step_size = 0;
+
+ // Init pointers
+ buf->mem = (unsigned char *)(buf->shm + sizeof(DltBufferHead));
+ buf->size = buf->min_size - sizeof(DltBufferHead);
- dlt_ringbuffer_checkandfreespace(dltbuf, (size+sui));
+ snprintf(str,sizeof(str),"Buffer: Size %d\n",buf->size);
+ dlt_log(LOG_INFO, str);
- if (dltbuf->pos_write >= dltbuf->size)
- {
- dltbuf->pos_write = 0;
- }
-
- /* Not enough space for one uint available before end of linear buffer */
- /* Start at begin of linear buffer */
- if ((dltbuf->size - dltbuf->pos_write) < sui)
- {
- dltbuf->pos_write = 0;
- }
-
- /* Write length of following data to buffer */
- memcpy(&(dltbuf->buffer[dltbuf->pos_write]), &size, sui);
- dltbuf->pos_write+=sui;
-
- if (dltbuf->pos_write >= dltbuf->size)
- {
- dltbuf->pos_write = 0;
- }
-
- if ((dltbuf->size - dltbuf->pos_write) < size)
- {
- /* Not enough space til end of linear buffer, */
- /* split up write call */
- part1 = dltbuf->size - dltbuf->pos_write;
- part2 = size - part1;
-
- memcpy(dltbuf->buffer + dltbuf->pos_write, data, part1);
- memcpy(dltbuf->buffer, ((char*)data) + part1, part2);
- dltbuf->pos_write = part2;
-
- }
- else
- {
- /* Enough space til end of linear buffer */
- memcpy(&(dltbuf->buffer[dltbuf->pos_write]), data, size);
- dltbuf->pos_write+=size;
- }
-
- dltbuf->count++;
-
- return 0;
+ return 0; /* OK */
}
-
-int dlt_ringbuffer_put3(DltRingBuffer *dltbuf, void *data1, uint32_t size1, void *data2, uint32_t size2, void *data3, uint32_t size3)
+int dlt_buffer_init_dynamic(DltBuffer *buf, uint32_t min_size, uint32_t max_size,uint32_t step_size)
{
- uint32_t sui, part1, part2;
- uint32_t total_size;
+ //Do not DLT_SEM_LOCK inside here!
+ char str[256];
+ DltBufferHead *head;
- if (dltbuf==0)
- {
- return -1;
- }
-
- if (dltbuf->buffer==0)
- {
- return -1;
- }
+ // Init parameters
+ buf->min_size = min_size;
+ buf->max_size = max_size;
+ buf->step_size = step_size;
- sui = sizeof(uint32_t);
-
- total_size = size1+size2+size3;
-
- if ((total_size+sui)>dltbuf->size)
- {
- return -1;
- }
+ // allocat memory
+ buf->shm = malloc(buf->min_size);
+ if(buf->shm == NULL) {
+ snprintf(str,sizeof(str),"Buffer: Cannot allocate %d bytes\n",buf->min_size);
+ dlt_log(LOG_EMERG, str);
+ return -1;
+ }
+
+ // Init pointers
+ head = (DltBufferHead*)buf->shm;
+ head->read = 0;
+ head->write = 0;
+ head->count = 0;
+ buf->mem = (unsigned char *)(buf->shm + sizeof(DltBufferHead));
+ buf->size = buf->min_size - sizeof(DltBufferHead);
+
+ // clear memory
+ memset(buf->mem,0,buf->size);
+
+ //snprintf(str,sizeof(str),"Buffer: Size %d bytes\n",buf->size);
+ //dlt_log(LOG_INFO, str);
- dlt_ringbuffer_checkandfreespace(dltbuf, (total_size+sui));
+ return 0; /* OK */
+}
- if (dltbuf->pos_write >= dltbuf->size)
- {
- dltbuf->pos_write = 0;
- }
+int dlt_buffer_free_static(DltBuffer *buf)
+{
+ if(!buf->mem) {
+ // buffer not initialised
+ dlt_log(LOG_ERR,"Buffer: Buffer not initialised\n");
+ return -1; /* ERROR */
+ }
- /* Not enough space for one uint available before end of linear buffer */
- /* Start at begin of linear buffer */
- if ((dltbuf->size - dltbuf->pos_write) < sui)
- {
- dltbuf->pos_write = 0;
- }
+ return 0;
+}
- /* Write length of following data to buffer */
- memcpy(&(dltbuf->buffer[dltbuf->pos_write]), &total_size, sui);
- dltbuf->pos_write+=sui;
+int dlt_buffer_free_dynamic(DltBuffer *buf)
+{
+ if(!buf->mem) {
+ // buffer not initialised
+ dlt_log(LOG_ERR,"Buffer: Buffer not initialised\n");
+ return -1; /* ERROR */
+ }
- if (dltbuf->pos_write >= dltbuf->size)
- {
- dltbuf->pos_write = 0;
- }
+ free(buf->shm);
+
+ return 0;
+}
- /* First chunk of data (data1, size1) */
- if ((dltbuf->size - dltbuf->pos_write) < size1)
- {
- /* Not enough space til end of linear buffer, */
- /* split up write call */
- part1 = dltbuf->size - dltbuf->pos_write;
- part2 = size1 - part1;
+void dlt_buffer_write_block(DltBuffer *buf,int *write, const unsigned char *data,unsigned int size)
+{
+ if((int)(*write+size) <= buf->size) {
+ // write one block
+ memcpy(buf->mem+*write,data,size);
+ *write += size;
+ }
+ else {
+ // write two blocks
+ memcpy(buf->mem+*write, data, buf->size-*write);
+ memcpy(buf->mem, data+buf->size-*write, size-buf->size+*write);
+ *write += size-buf->size;
+ }
+}
- memcpy(dltbuf->buffer + dltbuf->pos_write, data1, part1);
- memcpy(dltbuf->buffer, ((char*)data1) + part1, part2);
- dltbuf->pos_write = part2;
+void dlt_buffer_read_block(DltBuffer *buf,int *read,unsigned char *data,unsigned int size)
+{
+ if((int)(*read+size) <= buf->size) {
+ // read one block
+ memcpy(data,buf->mem+*read,size);
+ *read += size;
+ }
+ else {
+ // read two blocks
+ memcpy(data, buf->mem+*read, buf->size-*read);
+ memcpy(data+buf->size-*read, buf->mem, size-buf->size+*read);
+ *read += size-buf->size;
+ }
+}
+
+int dlt_buffer_increase_size(DltBuffer *buf)
+{
+ DltBufferHead *head,*new_head;
+ unsigned char *new_ptr;
+
+ /* check size */
+ if(buf->step_size==0) {
+ /* cannot increase size */
+ return -1;
+ }
- }
- else
- {
- /* Enough space til end of linear buffer */
- memcpy(&(dltbuf->buffer[dltbuf->pos_write]), data1, size1);
- dltbuf->pos_write+=size1;
- }
+ /* check size */
+ if((buf->size + sizeof(DltBufferHead) + buf->step_size) > buf->max_size) {
+ /* max size reached, do not increase */
+ return -1;
+ }
- if (dltbuf->pos_write >= dltbuf->size)
- {
- dltbuf->pos_write = 0;
- }
+ /* allocate new buffer */
+ new_ptr = malloc(buf->size + sizeof(DltBufferHead) + buf->step_size);
+ if(new_ptr == NULL) {
+ snprintf(str,sizeof(str),"Buffer: Cannot increase size because allocate %d bytes failed\n",buf->min_size);
+ dlt_log(LOG_WARNING, str);
+ return -1;
+ }
+
+ /* copy data */
+ head = (DltBufferHead*)buf->shm;
+ new_head = (DltBufferHead*)new_ptr;
+ if(head->read < head->write) {
+ memcpy(new_ptr+sizeof(DltBufferHead) , buf->mem+head->read , head->write-head->read);
+ new_head->read = 0;
+ new_head->write = head->write-head->read;
+ new_head->count = head->count;
+ }
+ else {
+ memcpy(new_ptr+sizeof(DltBufferHead) , buf->mem+head->read , buf->size-head->read);
+ memcpy(new_ptr+sizeof(DltBufferHead)+buf->size-head->read , buf->mem , head->write);
+ new_head->read = 0;
+ new_head->write = buf->size-head->read+head->write;
+ new_head->count = head->count;
+ }
+
+ /* free old data */
+ free(buf->shm);
+
+ /* update data */
+ buf->shm = new_ptr;
+ buf->mem = new_ptr+sizeof(DltBufferHead);
+ buf->size += buf->step_size;
+
+ snprintf(str,sizeof(str),"Buffer: Size increased to %d bytes\n",buf->size+sizeof(DltBufferHead));
+ dlt_log(LOG_INFO, str);
- /* Second chunk of data (data2, size2) */
- if ((dltbuf->size - dltbuf->pos_write) < size2)
- {
- /* Not enough space til end of linear buffer, */
- /* split up write call */
- part1 = dltbuf->size - dltbuf->pos_write;
- part2 = size2 - part1;
+ return 0; // OK
+}
- memcpy(dltbuf->buffer + dltbuf->pos_write, data2, part1);
- memcpy(dltbuf->buffer, ((char*)data2) + part1, part2);
- dltbuf->pos_write = part2;
+int dlt_buffer_minimize_size(DltBuffer *buf)
+{
+ unsigned char *new_ptr;
- }
- else
- {
- /* Enough space til end of linear buffer */
- memcpy(&(dltbuf->buffer[dltbuf->pos_write]), data2, size2);
- dltbuf->pos_write+=size2;
- }
+ if((buf->size + sizeof(DltBufferHead)) == buf->min_size)
+ {
+ /* already minimized */
+ return 0;
+ }
- if (dltbuf->pos_write >= dltbuf->size)
- {
- dltbuf->pos_write = 0;
- }
+ /* allocate new buffer */
+ new_ptr = malloc(buf->min_size);
+ if(new_ptr == NULL) {
+ snprintf(str,sizeof(str),"Buffer: Cannot set to min size of %d bytes\n",buf->min_size);
+ dlt_log(LOG_WARNING, str);
+ return -1;
+ }
- /* Third chunk of data (data3, size3) */
- if ((dltbuf->size - dltbuf->pos_write) < size3)
- {
- /* Not enough space til end of linear buffer, */
- /* split up write call */
- part1 = dltbuf->size - dltbuf->pos_write;
- part2 = size3 - part1;
+ /* free old data */
+ free(buf->shm);
+
+ /* update data */
+ buf->shm = new_ptr;
+ buf->mem = new_ptr+sizeof(DltBufferHead);
+ buf->size = buf->min_size - sizeof(DltBufferHead);
- memcpy(dltbuf->buffer + dltbuf->pos_write, data3, part1);
- memcpy(dltbuf->buffer, ((char*)data3) + part1, part2);
- dltbuf->pos_write = part2;
+ /* reset pointers and counters */
+ ((int*)(buf->shm))[0] = 0; // pointer to write memory
+ ((int*)(buf->shm))[1] = 0; // pointer to read memory
+ ((int*)(buf->shm))[2] = 0; // number of packets
- }
- else
- {
- /* Enough space til end of linear buffer */
- memcpy(dltbuf->buffer + dltbuf->pos_write, data3, size3);
- dltbuf->pos_write+=size3;
- }
+ // clear memory
+ memset(buf->mem,0,buf->size);
- dltbuf->count++;
+ dlt_log(LOG_INFO,"Buffer: Buffer minimized.\n");
- return 0;
+ return 0; /* OK */
}
-int dlt_ringbuffer_get(DltRingBuffer *dltbuf, void *data, size_t *size)
+int dlt_buffer_reset(DltBuffer *buf)
{
- uint32_t tmpsize=0;
- uint32_t sui;
+ dlt_log(LOG_ERR,"Buffer: Buffer reset triggered.\n");
- uint32_t part1, part2;
-
- if (dltbuf==0)
- {
- return -1;
- }
+ /* reset pointers and counters */
+ ((int*)(buf->shm))[0] = 0; // pointer to write memory
+ ((int*)(buf->shm))[1] = 0; // pointer to read memory
+ ((int*)(buf->shm))[2] = 0; // number of packets
- if (dltbuf->buffer==0)
- {
- return -1;
- }
+ // clear memory
+ memset(buf->mem,0,buf->size);
- if (dltbuf->count==0)
- {
- return -1;
- }
-
- sui = sizeof(uint32_t);
+ return 0; /* OK */
+}
- if (dltbuf->pos_read >= dltbuf->size)
- {
- dltbuf->pos_read = 0;
- }
+int dlt_buffer_push(DltBuffer *buf,const unsigned char *data,unsigned int size)
+{
+ return dlt_buffer_push3(buf,data,size,0,0,0,0);
+}
- if ((dltbuf->size - dltbuf->pos_read) < sui)
- {
- dltbuf->pos_read = 0;
- }
+int dlt_buffer_push3(DltBuffer *buf,const unsigned char *data1,unsigned int size1,const unsigned char *data2,unsigned int size2,const unsigned char *data3,unsigned int size3)
+{
+ int free_size;
+ int write, read, count;
+ DltBufferBlockHead head;
+
+ if(!buf->mem) {
+ // buffer not initialised
+ dlt_log(LOG_ERR,"Buffer: Buffer not initialised\n");
+ return -1; /* ERROR */
+ }
- /* printf("Reading at offset: %d\n", dltbuf->pos_read); */
+ // get current write pointer
+ write = ((int*)(buf->shm))[0];
+ read = ((int*)(buf->shm))[1];
+ count = ((int*)(buf->shm))[2];
- memcpy(&tmpsize,&(dltbuf->buffer[dltbuf->pos_read]), sui);
- dltbuf->pos_read += sui;
+ // check pointers
+ if((read>buf->size) || (write>buf->size))
+ {
+ dlt_log(LOG_ERR,"Buffer: Pointer out of range\n");
+ dlt_buffer_reset(buf);
+ return -1; // ERROR
+ }
- if (dltbuf->pos_read >= dltbuf->size)
- {
- dltbuf->pos_read = 0;
- }
+ // calculate free size
+ if(read>write)
+ free_size = read - write;
+ else if(count && (write == read))
+ free_size = 0;
+ else
+ free_size = buf->size - write + read;
+
+ // check size
+ if(free_size < (int)(sizeof(DltBufferBlockHead)+size1+size2+size3)) {
+ // 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");
+ return -1; // ERROR
+ }
+ // update pointers
+ write = ((int*)(buf->shm))[0];
+ read = ((int*)(buf->shm))[1];
+ }
- if ((tmpsize>0) && ((tmpsize+sizeof(uint32_t))<=dltbuf->size))
- {
- if ((dltbuf->size - dltbuf->pos_read) < tmpsize)
- {
- /* Not enough space til end of linear buffer, */
- /* split up read call */
- part1 = dltbuf->size - dltbuf->pos_read;
- part2 = tmpsize - part1;
+ // set header
+ strcpy(head.head,DLT_BUFFER_HEAD);
+ head.status = 2;
+ head.size = size1+size2+size3;
- memcpy(data, dltbuf->buffer + dltbuf->pos_read, part1);
- memcpy(((char*)data)+part1, dltbuf->buffer, part2);
- dltbuf->pos_read = part2;
- }
- else
- {
- /* Enough space til end of linear buffer */
- /* no split up read call */
- memcpy(data, &(dltbuf->buffer[dltbuf->pos_read]), tmpsize);
- dltbuf->pos_read+=tmpsize;
- }
- *size = tmpsize;
- }
- else
- {
- data=0;
- *size=0;
- }
+ // write data
+ dlt_buffer_write_block(buf,&write,(unsigned char*)&head,sizeof(DltBufferBlockHead));
+ if(size1) dlt_buffer_write_block(buf,&write,data1,size1);
+ if(size2) dlt_buffer_write_block(buf,&write,data2,size2);
+ if(size3) dlt_buffer_write_block(buf,&write,data3,size3);
- dltbuf->count--;
+ // update global shm pointers
+ ((int*)(buf->shm))[0] = write; // set new write pointer
+ ((int*)(buf->shm))[2] += 1; // increase counter
- return 0;
+ return 0; // OK
+
}
-int dlt_ringbuffer_get_skip(DltRingBuffer *dltbuf)
+int dlt_buffer_get(DltBuffer *buf,unsigned char *data, int max_size,int delete)
{
- uint32_t tmpsize=0;
- uint32_t sui;
+ int used_size;
+ int write, read, count;
+ char head_compare[] = DLT_BUFFER_HEAD;
+ DltBufferBlockHead head;
+
+ if(!buf->mem) {
+ // shm not initialised
+ dlt_log(LOG_ERR,"Buffer: SHM not initialised\n");
+ return -1; /* ERROR */
+ }
- uint32_t part1, part2;
+ // get current write pointer
+ write = ((int*)(buf->shm))[0];
+ read = ((int*)(buf->shm))[1];
+ count = ((int*)(buf->shm))[2];
- if (dltbuf==0)
- {
- return -1;
- }
+ // check pointers
+ if((read>buf->size) || (write>buf->size) || (count<0))
+ {
+ dlt_log(LOG_ERR,"Buffer: Pointer out of range\n");
+ dlt_buffer_reset(buf);
+ return -1; // ERROR
+ }
- if (dltbuf->buffer==0)
- {
- return -1;
- }
+ // check if data is in there
+ if(count==0) {
+ if(write!=read)
+ {
+ dlt_log(LOG_ERR,"Buffer: SHM should be empty, but is not\n");
+ dlt_buffer_reset(buf);
+ }
+ return -1; // ERROR
+ }
- if (dltbuf->count==0)
- {
- return -1;
- }
+ // calculate used size
+ if(write>read)
+ used_size = write - read;
+ else
+ used_size = buf->size - read + write;
+
+ // first check size
+ if(used_size < (int)(sizeof(DltBufferBlockHead))) {
+ dlt_log(LOG_ERR,"Buffer: Size check 1 failed\n");
+ dlt_buffer_reset(buf);
+ return -1; // ERROR
+ }
- sui = sizeof(uint32_t);
+ // read header
+ dlt_buffer_read_block(buf,&read,(unsigned char*)&head,sizeof(DltBufferBlockHead));
- if (dltbuf->pos_read >= dltbuf->size)
- {
- dltbuf->pos_read = 0;
- }
-
- if ((dltbuf->size - dltbuf->pos_read) < sui)
- {
- dltbuf->pos_read = 0;
- }
+ // check header
+ if(memcmp((unsigned char*)(head.head),head_compare,sizeof(head_compare))!=0)
+ {
+ dlt_log(LOG_ERR,"Buffer: Header head check failed\n");
+ dlt_buffer_reset(buf);
+ return -1; // ERROR
+ }
+ if(head.status != 2)
+ {
+ dlt_log(LOG_ERR,"Buffer: Header status check failed\n");
+ dlt_buffer_reset(buf);
+ return -1; // ERROR
+ }
- memcpy(&tmpsize,&(dltbuf->buffer[dltbuf->pos_read]), sui);
- dltbuf->pos_read += sui;
+ // second check size
+ if(used_size < (int)(sizeof(DltBufferBlockHead)+head.size)) {
+ dlt_log(LOG_ERR,"Buffer: Size check 2 failed\n");
+ dlt_buffer_reset(buf);
+ return -1; // ERROR
+ }
- if (dltbuf->pos_read >= dltbuf->size)
- {
- dltbuf->pos_read = 0;
- }
+ // third check size
+ if(max_size && (head.size > max_size)) {
+ dlt_log(LOG_ERR,"Buffer: Size check 3 failed\n");
+ // nothing to do but data does not fit provided buffer
+ }
- if ((tmpsize>0) && ((tmpsize+sui)<=dltbuf->size))
- {
- if ((dltbuf->size - dltbuf->pos_read) < tmpsize)
- {
- /* Not enough space til end of linear buffer */
- part1 = dltbuf->size - dltbuf->pos_read;
- part2 = tmpsize - part1;
+ if(data && max_size)
+ {
+ // read data
+ dlt_buffer_read_block(buf,&read,data,head.size);
- dltbuf->pos_read = part2;
- }
- else
- {
- /* Enough space til end of linear buffer */
- dltbuf->pos_read+=tmpsize;
- }
- }
+ if(delete)
+ {
+ // update buffer pointers
+ ((int*)(buf->shm))[1] = read; // set new read pointer
+ }
+ }
+ else
+ {
+ if(delete) {
+ if( (read+head.size) <= buf->size)
+ ((int*)(buf->shm))[1] = read+head.size; // set new read pointer
+ else
+ ((int*)(buf->shm))[1] = read+head.size-buf->size; // set new read pointer
+ }
+ }
+ if(delete) {
+ ((int*)(buf->shm))[2] -= 1; // decrease counter
+
+ if(((int*)(buf->shm))[2] == 0)
+ {
+ // try to minimize size
+ dlt_buffer_minimize_size(buf);
+ }
+ }
+
+ return head.size; // OK
+}
- dltbuf->count--;
+int dlt_buffer_pull(DltBuffer *buf,unsigned char *data, int max_size)
+{
+ return dlt_buffer_get(buf,data,max_size,1);
+}
- return 0;
+int dlt_buffer_copy(DltBuffer *buf,unsigned char *data, int max_size)
+{
+ return dlt_buffer_get(buf,data,max_size,0);
}
-int dlt_ringbuffer_freespacewrite(DltRingBuffer *dltbuf, uint32_t *freespace)
+int dlt_buffer_remove(DltBuffer *buf)
{
- if ((dltbuf==0) || (freespace==0))
- {
- return -1;
- }
+ return dlt_buffer_get(buf,0,0,1);
+}
- *freespace=0;
+void dlt_buffer_info(DltBuffer *buf)
+{
+ char str[256];
- /* Space til pos_read */
- if (dltbuf->pos_read > dltbuf->pos_write)
- {
- *freespace=(dltbuf->pos_read - dltbuf->pos_write);
- return 0;
- }
- else if (dltbuf->pos_read < dltbuf->pos_write)
- {
- *freespace=(dltbuf->size - dltbuf->pos_write + dltbuf->pos_read );
- return 0;
- }
- else
- {
- if (dltbuf->count)
- {
- return 0;
- }
- else
- {
- *freespace=dltbuf->size;
- return 0;
- }
- }
- return 0;
+ snprintf(str,sizeof(str),"Buffer: Available size: %d\n",buf->size);
+ dlt_log(LOG_INFO, str);
+ snprintf(str,sizeof(str),"Buffer: Buffer full start address: %lX\n",(unsigned long)buf->shm);
+ dlt_log(LOG_INFO, str);
+ snprintf(str,sizeof(str),"Buffer: Buffer start address: %lX\n",(unsigned long)buf->mem);
+ dlt_log(LOG_INFO, str);
+
}
-int dlt_ringbuffer_checkandfreespace(DltRingBuffer *dltbuf, uint32_t reqspace)
+void dlt_buffer_status(DltBuffer *buf)
{
- uint32_t space_left;
-
- if (dltbuf==0)
- {
- return -1;
- }
+ int write, read, count;
+ char str[256];
- if (dlt_ringbuffer_freespacewrite(dltbuf,&space_left) == -1)
- {
- return -1;
- }
+ write = ((int*)(buf->shm))[0];
+ read = ((int*)(buf->shm))[1];
+ count = ((int*)(buf->shm))[2];
- /* printf("Now reading at: %d, space_left = %d, req = %d, r=%d, w=%d, count=%d \n",
- dltbuf->pos_read,space_left, reqspace, dltbuf->pos_read, dltbuf->pos_write, dltbuf->count); */
+ snprintf(str,sizeof(str),"Buffer: Write: %d\n",write);
+ dlt_log(LOG_INFO, str);
+ snprintf(str,sizeof(str),"Buffer: Read: %d\n",read);
+ dlt_log(LOG_INFO, str);
+ snprintf(str,sizeof(str),"Buffer: Count: %d\n",count);
+ dlt_log(LOG_INFO, str);
+}
- while (space_left<reqspace)
- {
- /* Overwrite, correct read position */
+int dlt_buffer_get_total_size(DltBuffer *buf)
+{
+ return buf->max_size;
+}
- /* Read and skip one element */
- dlt_ringbuffer_get_skip(dltbuf);
+int dlt_buffer_get_used_size(DltBuffer *buf)
+{
+ int write, read, count;
- /* Space until pos_read */
- if (dlt_ringbuffer_freespacewrite(dltbuf,&space_left) == -1)
- {
- return -1;
- }
+ write = ((int*)(buf->shm))[0];
+ read = ((int*)(buf->shm))[1];
+ count = ((int*)(buf->shm))[2];
- /* printf("Overwrite: Now reading at: %d, space_left = %d, req = %d, r=%d, w=%d, count=%d \n",
- dltbuf->pos_read,space_left, reqspace, dltbuf->pos_read, dltbuf->pos_write, dltbuf->count); */
- }
+ if(count == 0)
+ return 0;
+
+ if(write>read)
+ return (write - read);
+
+ return (buf->size - read + write);
+}
- return 0;
+int dlt_buffer_get_message_count(DltBuffer *buf)
+{
+ return ((int*)(buf->shm))[2];
}
#if !defined (__WIN32__)
void dlt_get_version(char *buf)
{
- sprintf(buf,"DLT Package Version: %s %s, Package Revision: %s, build on %s %s\n",
- PACKAGE_VERSION, PACKAGE_VERSION_STATE, PACKAGE_REVISION, __DATE__ , __TIME__ );
+ sprintf(buf,"DLT Package Version: %s %s, Package Revision: %s, build on %s %s\n%s %s %s %s\n",
+ _DLT_PACKAGE_VERSION, _DLT_PACKAGE_VERSION_STATE, _DLT_PACKAGE_REVISION, __DATE__ , __TIME__,_DLT_SYSTEMD_ENABLE,_DLT_SYSTEMD_WATCHDOG_ENABLE,_DLT_TEST_ENABLE,_DLT_SHM_ENABLE );
}
void dlt_get_major_version(char *buf)
{
- sprintf(buf,"%s",PACKAGE_MAJOR_VERSION);
+ sprintf(buf,"%s",_DLT_PACKAGE_MAJOR_VERSION);
}
void dlt_get_minor_version(char *buf)
{
- sprintf(buf,"%s",PACKAGE_MINOR_VERSION);
+ sprintf(buf,"%s",_DLT_PACKAGE_MINOR_VERSION);
}
struct timespec ts;
if (clock_gettime(CLOCK_MONOTONIC,&ts)==0)
- {
- return (uint32_t)((((ts.tv_sec*1000000)+(ts.tv_nsec/1000)))/100); // in 0.1 ms = 100 us
+ {
+ return ( (uint32_t)ts.tv_sec*10000 + (uint32_t)ts.tv_nsec/100000 );// in 0.1 ms = 100 us
}
else
{
float64_t value64f=0,value64f_tmp=0;
int64_t value64f_tmp_int64i=0,value64f_tmp_int64i_swaped=0;
- uint32_t quantisation=0, quantisation_tmp=0;
+ uint32_t quantisation_tmp=0;
if (type_info & DLT_TYPE_INFO_STRG)
{
return -1;
sprintf(text+strlen(text),"%d",value8u);
}
- else if (type_info & DLT_TYPE_INFO_SINT || type_info & DLT_TYPE_INFO_UINT)
+ else if ((type_info & DLT_TYPE_INFO_SINT) || (type_info & DLT_TYPE_INFO_UINT))
{
/* signed or unsigned argument received */
if (type_info & DLT_TYPE_INFO_VARI)
}
if (type_info & DLT_TYPE_INFO_FIXP)
{
- quantisation=0;
- quantisation_tmp=0;
+ //compiler warning: variable ‘quantisation_tmp’ set but not used [-Wunused-but-set-variable], but: DLT_MSG_READ_VALUE wants a parameter, "0" does not work
DLT_MSG_READ_VALUE(quantisation_tmp,*ptr,*datalength,uint32_t);
+
if((*datalength)<0)
return -1;
- quantisation=DLT_ENDIAN_GET_32(msg->standardheader->htyp, quantisation_tmp);
-
switch ( type_info & DLT_TYPE_INFO_TYLE)
{
case DLT_TYLE_8BIT:
projects / profile / ivi / dlt-daemon.git / blobdiff