Changeset 0a474e3


Ignore:
Timestamp:
11/27/18 10:18:20 (2 years ago)
Author:
Jacob Van Walraven <jcv9@…>
Branches:
develop
Children:
b6ff245
Parents:
88b9798
Message:

And more..

Location:
lib
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • lib/data-struct/message_queue.c

    r88b9798 r0a474e3  
    7474        int ret;
    7575        /*assert(mq->message_len);*/
     76        //if (!mq->message_len) {
     77        //      fprintf(stderr, "Message queue must be initialised with libtrace_message_queue_init()"
     78        //              "before inserting messages in libtrace_message_queue_put()\n");
     79        //      /* Can we return -1 here as this could imply threads are waiting */
     80        //      return -1;
     81        //}
    7682        ASSERT_RET(write(mq->pipefd[1], message, mq->message_len), == (int) mq->message_len);
    7783        // Update after we've written
  • lib/data-struct/object_cache.c

    ree6e802 r0a474e3  
    143143 */
    144144static void resize_memory_caches(struct local_caches *lcs) {
    145         assert (lcs->t_mem_caches_total > 0);
     145        /*assert (lcs->t_mem_caches_total > 0);*/
     146        if (lcs->t_mem_caches_total <= 0) {
     147
     148        }
    146149        lcs->t_mem_caches += 0x10;
    147150        lcs->t_mem_caches = realloc(lcs->t_mem_caches,
     
    166169                /* This thread has not been used with a memory pool before */
    167170                /* Allocate our TLS */
    168                 assert(lcs == NULL);
     171                /*assert(lcs == NULL);*/
     172                if (lcs) {
     173                        fprintf(stderr, "Expected lcs to be NULL in get_local_caches()\n");
     174                        return NULL;
     175                }
    169176                lcs = calloc(1, sizeof (struct local_caches));
    170                 assert(lcs);
     177                /*assert(lcs);*/
     178                if (!lcs) {
     179                        fprintf(stderr, "Unable to allocate memory for lcs in get_local_caches()\n");
     180                        return NULL;
     181                }
    171182                /* Hook into pthreads to destroy this when the thread ends */
    172183                pthread_once(&memory_destructor_once, &once_memory_cache_key_init);
     
    174185                lcs->t_mem_caches_total = 0x10;
    175186                lcs->t_mem_caches = calloc(0x10, sizeof(struct local_cache));
    176                 assert(lcs);
    177                 assert(lcs->t_mem_caches);
     187                /*assert(lcs);*/
     188                /*assert(lcs->t_mem_caches);*/
     189                if (!lcs->t_mem_caches) {
     190                        fprintf(stderr, "Unable to allocate memory for lcs->t_mem_caches in get_local_cahces()\n");
     191                        return NULL;
     192                }
    178193                return lcs;
    179194        }
     
    210225        }
    211226
    212         assert(!lc->invalid);
     227        /*assert(!lc->invalid);*/
     228        if (lc->invalid) {
     229                fprintf(stderr, "lc cache is invalid in find_cache()\n");
     230                return NULL;
     231        }
    213232        return lc;
    214233}
     
    246265                                    size_t buffer_size, bool limit_size) {
    247266
    248         assert(buffer_size);
    249         assert(alloc);
    250         assert(free);
     267        /*assert(buffer_size);*/
     268        if (!buffer_size) {
     269                fprintf(stderr, "NULL bugger_size passed into libtrace_ocache_init()\n");
     270                return -1;
     271        }
     272        /*assert(alloc);*/
     273        if (!alloc) {
     274                fprintf(stderr, "NULL alloc passed into libtrace_ocache_init()\n");
     275                return -1;
     276        }
     277        /*assert(free);*/
     278        if (!free) {
     279                fprintf(stderr, "NULL free method passed into libtrace_ocache_init()\n");
     280                return -1;
     281        }
    251282        if (libtrace_ringbuffer_init(&oc->rb, buffer_size, LIBTRACE_RINGBUFFER_BLOCKING) != 0) {
    252283                return -1;
     
    366397        mem_hits.read.miss += nb_buffers - i;
    367398#endif
    368         assert(i >= min_nb_buffers);
     399        /*assert(i >= min_nb_buffers);*/
     400        if (i < min_nb_buffers) {
     401                fprintf(stderr, "Unable to fill remaining cache in libtrace_ocache_alloc_cache()\n");
     402                return ~0U;
     403        }
    369404        return i;
    370405}
     
    399434                for (;i < nb; ++i) {
    400435                        values[i] = (*oc->alloc)();
    401                         assert(values[i]);
    402                 }
    403                 assert (i == nb);
     436                        /*assert(values[i]);*/
     437                        if (!values[i]) {
     438                                fprintf(stderr, "Unable to alloc memory for values[%zu] in libtrace_ocache_alloc()\n", i);
     439                                return ~0U;
     440                        }
     441                }
     442                /*assert (i == nb);*/
     443                if (i != nb) {
     444                        fprintf(stderr, "Expected i == nb in libtrace_ocache_alloc()\n");
     445                        return ~0U;
     446                }
    404447                // Still got to wait for more
    405448                if (nb < min_nb_buffers) {
     
    410453                }
    411454        }
    412         assert(i >= min_nb_buffers);
     455        /*assert(i >= min_nb_buffers);*/
     456        if (i < min_nb_buffers) {
     457                fprintf(stderr, "Expected min_nb_buffers to be equal or less than i in libtrace_ocache_alloc()\n");
     458                return ~0U;
     459        }
    413460        return i;
    414461}
  • lib/data-struct/ring_buffer.c

    ree6e802 r0a474e3  
    269269        size_t i = 0;
    270270       
    271         assert(min_nb_buffers <= nb_buffers);
     271        /*assert(min_nb_buffers <= nb_buffers);*/
     272        if (min_nb_buffers > nb_buffers) {
     273                fprintf(stderr, "min_nb_buffers must be greater than or equal to nb_buffers in libtrace_ringbuffer_write_bulk()\n");
     274                return ~0U;
     275        }
    272276        if (!min_nb_buffers && libtrace_ringbuffer_is_full(rb))
    273277                return 0;
     
    346350        size_t nb_ready;
    347351        size_t i = 0;
    348        
    349         assert(min_nb_buffers <= nb_buffers);
     352
     353        /*assert(min_nb_buffers <= nb_buffers);*/
     354        if (min_nb_buffers > nb_buffers) {
     355                fprintf(stderr, "min_nb_buffers must be greater than or equal to nb_buffers in libtrace_ringbuffer_write_bulk()\n");
     356                return ~0U;
     357        }
    350358
    351359        if (!min_nb_buffers && libtrace_ringbuffer_is_empty(rb))
  • lib/data-struct/sliding_window.c

    ree6e802 r0a474e3  
    3030#include <string.h>
    3131
     32#include <stdio.h>
    3233/**
    3334 * Implements a sliding window via a ring buffer, this is a fixed size.
     
    4344        sw->start = 0;
    4445        sw->elements = calloc(sw->size, sizeof(void*));
    45         assert(sw->elements);
     46        /*assert(sw->elements);*/
     47        if (!sw->elements) {
     48                fprintf(stderr, "Unable to allocate memory for sw->elements in libtrace_slidingwindow_init()\n");
     49                return;
     50        }
    4651        memset((void *) sw->elements, 0, sizeof(void*) * sw->size);
    4752        sw->start_number = start_number;
  • lib/data-struct/vector.c

    ree6e802 r0a474e3  
    5454                v->max_size *= 2;
    5555                v->elements = realloc(v->elements, v->max_size * v->element_size);
    56                 assert(v->elements);
     56                /*assert(v->elements);*/
     57                if (!v->elements) {
     58                        fprintf(stderr, "Unable to allocate memory for v->elements in libtrace_vector_push_back()\n");
     59                        return;
     60                }
    5761        }
    5862        memcpy(&v->elements[v->size*v->element_size], d, v->element_size);
     
    104108DLLEXPORT void libtrace_vector_append(libtrace_vector_t *dest, libtrace_vector_t *src)
    105109{
    106         assert(dest->element_size == src->element_size);
     110        /*assert(dest->element_size == src->element_size);*/
     111        if (dest->element_size != src->element_size) {
     112                fprintf(stderr, "Elements must be the same size in libtrace_vector_append()\n");
     113                return;
     114        }
    107115        if (src->size == 0) // Nothing to do if this is the case
    108116                return;
  • lib/format_dpdkndag.c

    r25a3255 r0a474e3  
    9898        scan = strchr(libtrace->uridata, ',');
    9999        if (scan == NULL) {
    100                 free(libtrace->format_data);
    101100                trace_set_err(libtrace, TRACE_ERR_BAD_FORMAT,
    102101                        "Bad dpdkndag URI. Should be dpdkndag:<interface>,<multicast group>");
     
    115114        if (getaddrinfo(next, NULL, &hints, &result) != 0) {
    116115                perror("getaddrinfo");
    117                 free(libtrace->format_data);
    118116                trace_set_err(libtrace, TRACE_ERR_BAD_FORMAT,
    119117                        "Invalid multicast address: %s", next);
Note: See TracChangeset for help on using the changeset viewer.