Ignore:
Timestamp:
11/26/18 16:46:37 (2 years ago)
Author:
Jacob Van Walraven <jcv9@…>
Branches:
develop
Children:
f6f3ae5
Parents:
25a3255
Message:

Assertion cleanups

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/trace_parallel.c

    r37ee856 r2ceec6a  
    271271DLLEXPORT bool trace_has_reporter(libtrace_t * libtrace)
    272272{
    273         assert(libtrace->state != STATE_NEW);
     273        /*assert(libtrace->state != STATE_NEW);*/
     274        if (!(libtrace->stats != STATE_NEW)) {
     275                trace_set_err(libtrace, TRACE_ERR_BAD_STATE, "Cannot check reporter for the current state in trace_has_reporter()");
     276                return false;
     277        }
    274278        return libtrace->reporter_thread.type == THREAD_REPORTER && libtrace->reporter_cbs;
    275279}
     
    368372static inline bool trace_supports_parallel(libtrace_t *trace)
    369373{
    370         assert(trace);
    371         assert(trace->format);
     374        /*assert(trace);*/
     375        if (!trace) {
     376                fprintf(stderr, "NULL trace passed into trace_supports_parallel()\n");
     377                return false;
     378        }
     379        /*assert(trace->format);*/
     380        if (!trace->format) {
     381                trace_set_err(trace, TRACE_ERR_BAD_FORMAT,
     382                        "NULL capture format associated with trace in trace_supports_parallel()");
     383                return false;
     384        }
    372385        if (trace->format->pstart_input)
    373386                return true;
     
    490503                trace_fin_packet(*packet);
    491504        } else {
    492                 assert((*packet)->error == READ_TICK);
     505                /*assert((*packet)->error == READ_TICK);*/
     506                if (!((*packet)->error == READ_TICK)) {
     507                        trace_set_err(trace, TRACE_ERR_BAD_STATE,
     508                                "Packet is not in READ_TICK state in dispath_packet()");
     509                        return -1;
     510                }
    493511                libtrace_generic_t data = {.uint64 = trace_packet_get_order(*packet)};
    494512                send_message(trace, t, MESSAGE_TICK_COUNT, data, t);
     
    533551                } else {
    534552                        /* Break early */
    535                         assert(ret == READ_MESSAGE);
     553                        /*assert(ret == READ_MESSAGE);*/
     554                        if (!(ret == READ_MESSAGE)) {
     555                                trace_set_err(trace, TRACE_ERR_UNKNOWN_OPTION,
     556                                        "Expected READ_MESSAGE in dispatch_packets()");
     557                                return -1;
     558                        }
    536559                        return READ_MESSAGE;
    537560                }
     
    583606                        } else if (ret != READ_MESSAGE) {
    584607                                /* Ignore messages we pick these up next loop */
    585                                 assert (ret == READ_EOF || ret == READ_ERROR);
     608                                /*assert (ret == READ_EOF || ret == READ_ERROR);*/
     609                                if (!(ret == READ_EOF || ret == READ_ERROR)) {
     610                                        trace_set_err(trace, TRACE_ERR_PAUSE_PTHREAD,
     611                                                "Error pausing processing thread in trace_perpkt_thread_pause()");
     612                                        return -1;
     613                                }
    586614                                /* Verify no packets are remaining */
    587615                                /* TODO refactor this sanity check out!! */
     
    589617                                        ASSERT_RET(trace->pread(trace, t, &packet, 1), <= 0);
    590618                                        // No packets after this should have any data in them
    591                                         assert(packet->error <= 0);
     619                                        /*assert(packet->error <= 0);*/
     620                                        if (!(packet->error <= 0)) {
     621                                                trace_set_err(trace, TRACE_ERR_BAD_PACKET,
     622                                                        "Expected no data from packets however found some in trace_perpkt_thread_pause()");
     623                                                return -1;
     624                                        }
    592625                                }
    593626                                libtrace_ocache_free(&trace->packet_freelist, (void **) &packet, 1, 1);
     
    625658        ASSERT_RET(pthread_mutex_lock(&trace->libtrace_lock), == 0);
    626659        t = get_thread_table(trace);
    627         assert(t);
     660        /*assert(t);*/
     661        if (!t) {
     662                trace_set_err(trace, TRACE_ERR_THREAD, "Unable to get thread table in perpkt_threads_entry()");
     663                return NULL;
     664        }
    628665        if (trace->state == STATE_ERROR) {
    629666                thread_change_state(trace, t, THREAD_FINISHED, false);
     
    666703                                                goto error;
    667704                                        }
    668                                         assert(ret == 1);
     705                                        /*assert(ret == 1);*/
     706                                        if (!(ret == 1)) {
     707                                                fprintf(stderr, "Unknown error pausing thread in perpkt_threads_entry()\n");
     708                                                return NULL;
     709                                        }
    669710                                        continue;
    670711                                case MESSAGE_DO_STOP: // This is internal
     
    689730                        }
    690731                        if (!trace->pread) {
    691                                 assert(packets[0]);
     732                                /*assert(packets[0]);*/
     733                                if (!packets[0]) {
     734                                        fprintf(stderr, "Packet missing in perpkt_threads_entry()\n");
     735                                        return NULL;
     736                                }
    692737                                nb_packets = trace_read_packet(trace, packets[0]);
    693738                                packets[0]->error = nb_packets;
     
    781826        int pkt_skipped = 0;
    782827
    783         assert(trace_has_dedicated_hasher(trace));
     828        /*assert(trace_has_dedicated_hasher(trace));*/
     829        if (!trace_has_dedicated_hasher(trace)) {
     830                fprintf(stderr, "Trace does not have hasher associated with it in hasher_entry()\n");
     831                return NULL;
     832        }
    784833        /* Wait until all threads are started and objects are initialised (ring buffers) */
    785834        ASSERT_RET(pthread_mutex_lock(&trace->libtrace_lock), == 0);
    786835        t = &trace->hasher_thread;
    787         assert(t->type == THREAD_HASHER && pthread_equal(pthread_self(), t->tid));
     836        /*assert(t->type == THREAD_HASHER && pthread_equal(pthread_self(), t->tid));*/
     837        if (!(t->type == THREAD_HASHER && pthread_equal(pthread_self(), t->tid))) {
     838                fprintf(stderr, "Incorrect thread type or non matching thread IDs in hasher_entry()\n");
     839                return NULL;
     840        }
     841
    788842        if (trace->state == STATE_ERROR) {
    789843                thread_change_state(trace, t, THREAD_FINISHED, false);
     
    803857                if (!pkt_skipped)
    804858                        libtrace_ocache_alloc(&trace->packet_freelist, (void **) &packet, 1, 1);
    805                 assert(packet);
     859                /*assert(packet);*/
     860                if (!packet) {
     861                        fprintf(stderr, "Cannot hash and queue a NULL packet in hasher_entry()\n");
     862                        return NULL;
     863                }
    806864
    807865                // Check for messages that we expect MESSAGE_DO_PAUSE, (internal messages only)
     
    821879                                case MESSAGE_DO_STOP:
    822880                                        /* Either FINISHED or FINISHING */
    823                                         assert(trace->started == false);
     881                                        /*assert(trace->started == false);*/
     882                                        if (!(trace->started == false)) {
     883                                                fprintf(stderr, "Expected trace to have not started in hasher_entry()\n");
     884                                                return NULL;
     885                                        }
    824886                                        /* Mark the current packet as EOF */
    825887                                        packet->error = 0;
     
    861923                        pkt_skipped = 0;
    862924                } else {
    863                         assert(!"Dropping a packet!!");
     925                        /*assert(!"Dropping a packet!!");*/
     926                        fprintf(stderr, "Expected THREAD_FINISHED state in hasher_entry()\n");
     927                        return NULL;
    864928                        pkt_skipped = 1; // Reuse that packet no one read it
    865929                }
     
    9901054                           sent once*/
    9911055                        if (packets[i]->error != READ_MESSAGE) {
    992                                 assert(t->format_data == NULL);
     1056                                /*assert(t->format_data == NULL);*/
     1057                                if (!(t->format_data == NULL)) {
     1058                                        trace_set_err(libtrace, TRACE_ERR_BAD_FORMAT,
     1059                                                "Expected format data to be NULL in trace_pread_packet_hasher_thread()");
     1060                                        return -1;
     1061                                }
    9931062                                t->format_data = packets[i];
    9941063                        }
     
    11501219                                break;
    11511220                        case MESSAGE_DO_PAUSE:
    1152                                 assert(trace->combiner.pause);
     1221                                /*assert(trace->combiner.pause);*/
     1222                                if(!(trace->combiner.pause)) {
     1223                                        trace_set_err(trace, TRACE_ERR_COMBINER,
     1224                                                "Expected combiner to be paused in reporter_entry()");
     1225                                        return NULL;
     1226                                }
    11531227                                trace->combiner.pause(trace, &trace->combiner);
    11541228                                send_message(trace, t, MESSAGE_PAUSING,
     
    12091283                                libtrace_message_t msg;
    12101284                                libtrace_message_queue_get(&t->messages, &msg);
    1211                                 assert(msg.code == MESSAGE_DO_STOP);
     1285                                /*assert(msg.code == MESSAGE_DO_STOP);*/
     1286                                if (!(msg.code == MESSAGE_DO_STOP)) {
     1287                                        fprintf(stderr, "Unexpected message code in keepalive_entry()\n");
     1288                                        return NULL;
     1289                                }
    12121290                                goto done;
    12131291                        }
     
    12731351                        return READ_MESSAGE;
    12741352                } else {
    1275                         assert(!"trace_delay_packet: Unexpected return from select");
     1353                        /*assert(!"trace_delay_packet: Unexpected return from select");*/
     1354                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Unexpected return from select in delay_tracetime()");
     1355                        return -1;
    12761356                }
    12771357        }
     
    13251405                                      size_t nb_packets) {
    13261406        int i;
    1327         assert(nb_packets);
    1328         assert(libtrace && "libtrace is NULL in trace_read_packet()");
     1407        /*assert(libtrace && "libtrace is NULL in trace_read_packet()");*/
     1408        if (!libtrace) {
     1409                fprintf(stderr, "NULL trace passed into trace_read_packet()\n");
     1410                return TRACE_ERR_NULL_TRACE;
     1411        }
     1412        /*assert(nb_packets);*/
     1413        if (!nb_packets) {
     1414                trace_set_err(libtrace, TRACE_ERR_NULL,
     1415                        "NULL nb_packets passed into trace_pread_packet_wrapper()");
     1416                return -1;
     1417        }
    13291418        if (trace_is_err(libtrace))
    13301419                return -1;
     
    13381427                int ret;
    13391428                for (i = 0; i < (int) nb_packets; ++i) {
    1340                         assert(i[packets]);
     1429                        /*assert(i[packets]); <--- is this ment to be packets[i]?? */
     1430                        if (!i[packets]) {
     1431                                trace_set_err(libtrace, TRACE_ERR_BAD_STATE, "NULL packets in trace_read_packet()");
     1432                                return -1;
     1433                        }
    13411434                        if (!(packets[i]->buf_control==TRACE_CTRL_PACKET ||
    13421435                              packets[i]->buf_control==TRACE_CTRL_EXTERNAL)) {
     
    13971490        }
    13981491
    1399         assert(libtrace_parallel);
    1400         assert(!libtrace->perpkt_thread_states[THREAD_RUNNING]);
     1492        /*assert(libtrace_parallel);*/
     1493        if (!libtrace_parallel) {
     1494                trace_set_err(libtrace, TRACE_ERR_THREAD, "Expected parallel trace in trace_prestart()");
     1495                return -1;
     1496        }
     1497        /*assert(!libtrace->perpkt_thread_states[THREAD_RUNNING]);*/
     1498        if (!(!libtrace->perpkt_thread_states[THREAD_RUNNING])) {
     1499                trace_set_err(libtrace, TRACE_ERR_THREAD, "Expected no running threads in trace_prestart()");
     1500                return -1;
     1501        }
    14011502
    14021503        /* Reset first packets */
    14031504        pthread_spin_lock(&libtrace->first_packets.lock);
    14041505        for (i = 0; i < libtrace->perpkt_thread_count; ++i) {
    1405                 assert(!!libtrace->perpkt_threads[i].recorded_first == !!libtrace->first_packets.packets[i].packet);
     1506                /*assert(!!libtrace->perpkt_threads[i].recorded_first == !!libtrace->first_packets.packets[i].packet);*/
     1507                if (!(!!libtrace->perpkt_threads[i].recorded_first == !!libtrace->first_packets.packets[i].packet)) {
     1508                        trace_set_err(libtrace, TRACE_ERR_THREAD, "Expected different first packet in trace_pstart()");
     1509                        return -1;
     1510                }
    14061511                if (libtrace->first_packets.packets[i].packet) {
    14071512                        trace_destroy_packet(libtrace->first_packets.packets[i].packet);
     
    14131518                }
    14141519        }
    1415         assert(libtrace->first_packets.count == 0);
     1520        /*assert(libtrace->first_packets.count == 0);*/
     1521        if (!(libtrace->first_packets.count == 0)) {
     1522                trace_set_err(libtrace, TRACE_ERR_THREAD, "Expected a first packets count of 0 in trace_pstart()");
     1523                return -1;
     1524        }
    14161525        libtrace->first_packets.first = 0;
    14171526        pthread_spin_unlock(&libtrace->first_packets.lock);
     
    14471556
    14481557                libtrace->reporter_cbs = trace_create_callback_set();
    1449                 memcpy(libtrace->reporter_cbs, reporter_cbs, 
     1558                memcpy(libtrace->reporter_cbs, reporter_cbs,
    14501559                                sizeof(libtrace_callback_set_t));
    14511560        }
     
    15521661#endif
    15531662        int ret;
    1554         assert(t->type == THREAD_EMPTY);
     1663        /*assert(t->type == THREAD_EMPTY);*/
     1664        if (!(t->type == THREAD_EMPTY)) {
     1665                trace_set_err(trace, TRACE_ERR_THREAD,
     1666                        "Expected thread type of THREAD_EMPTY in trace_start_thread()");
     1667                return -1;
     1668        }
    15551669        t->trace = trace;
    15561670        t->ret = NULL;
     
    15591673        t->state = THREAD_RUNNING;
    15601674
    1561         assert(name);
     1675        /*assert(name);*/
     1676        if (!name) {
     1677                trace_set_err(trace, TRACE_ERR_THREAD, "NULL thread name in trace_start_thread()");
     1678                return -1;
     1679        }
    15621680
    15631681#ifdef __linux__
     
    16821800        char name[24];
    16831801        sigset_t sig_before, sig_block_all;
    1684         assert(libtrace);
     1802        /*assert(libtrace);*/
     1803        if (!libtrace) {
     1804                fprintf(stderr, "NULL trace passed to trace_pstart()\n");
     1805                return -1;
     1806        }
    16851807
    16861808        ASSERT_RET(pthread_mutex_lock(&libtrace->libtrace_lock), == 0);
     
    19042026        ASSERT_RET(pthread_mutex_lock(&libtrace->libtrace_lock), == 0);
    19052027        libtrace_change_state(libtrace, STATE_NEW, false);
    1906         assert(libtrace->perpkt_thread_states[THREAD_RUNNING] == 0);
     2028        /*assert(libtrace->perpkt_thread_states[THREAD_RUNNING] == 0);*/
     2029        if (!(libtrace->perpkt_thread_states[THREAD_RUNNING] == 0)) {
     2030                trace_set_err(libtrace, TRACE_ERR_THREAD, "Expected 0 running threads in trace_pstart()");
     2031                return -1;
     2032        }
    19072033        libtrace->perpkt_thread_states[THREAD_FINISHED] = 0;
    19082034cleanup_started:
     
    19962122        libtrace_thread_t *t;
    19972123        int i;
    1998         assert(libtrace);
     2124        /*assert(libtrace);*/
     2125        if (!libtrace) {
     2126                fprintf(stderr, "NULL trace passed into trace_ppause()\n");
     2127                return TRACE_ERR_NULL_TRACE;
     2128        }
    19992129
    20002130        t = get_thread_table(libtrace);
     
    21292259        int i, err;
    21302260        libtrace_message_t message = {0, {.uint64=0}, NULL};
    2131         assert(libtrace);
     2261        /*assert(libtrace);*/
     2262        if (!libtrace) {
     2263                fprintf(stderr, "NULL trace passed into trace_pstop()\n");
     2264                return TRACE_ERR_NULL_TRACE;
     2265        }
    21322266
    21332267        // Ensure all threads have paused and the underlying trace format has
     
    22272361                // the producer (or any other threads) don't block.
    22282362                libtrace_packet_t * packet;
    2229                 assert(libtrace->perpkt_threads[i].state == THREAD_FINISHED);
     2363                /*assert(libtrace->perpkt_threads[i].state == THREAD_FINISHED);*/
     2364                if (!(libtrace->perpkt_threads[i].state == THREAD_FINISHED)) {
     2365                        trace_set_err(libtrace, TRACE_ERR_THREAD_STATE,
     2366                                "Expected processing threads state THREAD_FINISHED in trace_join()");
     2367                        return;
     2368                }
    22302369                while(libtrace_ringbuffer_try_read(&libtrace->perpkt_threads[i].rbuffer, (void **) &packet))
    22312370                        if (packet) // This could be NULL iff the perpkt finishes early
     
    22362375        if (trace_has_dedicated_hasher(libtrace)) {
    22372376                pthread_join(libtrace->hasher_thread.tid, NULL);
    2238                 assert(libtrace->hasher_thread.state == THREAD_FINISHED);
     2377                /*assert(libtrace->hasher_thread.state == THREAD_FINISHED);*/
     2378                if (!(libtrace->hasher_thread.state == THREAD_FINISHED)) {
     2379                        trace_set_err(libtrace, TRACE_ERR_THREAD_STATE,
     2380                                "Expected hasher thread state THREAD_FINISHED in trace_join()");
     2381                        return;
     2382                }
    22392383        }
    22402384
     
    22482392                        trace_destroy_packet(packet);
    22492393                if (trace_has_dedicated_hasher(libtrace)) {
    2250                         assert(libtrace_ringbuffer_is_empty(&libtrace->perpkt_threads[i].rbuffer));
     2394                        /*assert(libtrace_ringbuffer_is_empty(&libtrace->perpkt_threads[i].rbuffer));*/
     2395                        if (!(libtrace_ringbuffer_is_empty(&libtrace->perpkt_threads[i].rbuffer))) {
     2396                                trace_set_err(libtrace, TRACE_ERR_THREAD,
     2397                                        "Expected processing threads ring buffers to be empty in trace_join()");
     2398                                return;
     2399                        }
    22512400                        libtrace_ringbuffer_destroy(&libtrace->perpkt_threads[i].rbuffer);
    22522401                }
     
    22562405        if (trace_has_reporter(libtrace)) {
    22572406                pthread_join(libtrace->reporter_thread.tid, NULL);
    2258                 assert(libtrace->reporter_thread.state == THREAD_FINISHED);
     2407                /*assert(libtrace->reporter_thread.state == THREAD_FINISHED);*/
     2408                if (!(libtrace->reporter_thread.state == THREAD_FINISHED)) {
     2409                        trace_set_err(libtrace, TRACE_ERR_THREAD_STATE,
     2410                                "Expected reporting thread state to be THREAD_FINISHED in trace_join()");
     2411                        return;
     2412                }
    22592413        }
    22602414
     
    25152669/* Note update documentation on trace_set_configuration */
    25162670static void config_string(struct user_configuration *uc, char *key, size_t nkey, char *value, size_t nvalue) {
    2517         assert(key);
    2518         assert(value);
    2519         assert(uc);
     2671        /*assert(key);*/
     2672        if (!key) {
     2673                fprintf(stderr, "NULL key passed to config_string()\n");
     2674                return;
     2675        }
     2676        /*assert(value);*/
     2677        if (!value) {
     2678                fprintf(stderr, "NULL value passed to config_string()\n");
     2679                return;
     2680        }
     2681        /*assert(uc);*/
     2682        if (!uc) {
     2683                fprintf(stderr, "NULL uc (user_configuration) passed to config_string()\n");
     2684                return;
     2685        }
    25202686        if (strncmp(key, "cache_size", nkey) == 0
    25212687            || strncmp(key, "cs", nkey) == 0) {
     
    25642730        char value[100];
    25652731        char *dup;
    2566         assert(str);
    2567         assert(trace);
     2732        /*assert(trace);*/
     2733        if (!trace) {
     2734                fprintf(stderr, "NULL trace passed into trace_set_configuration()\n");
     2735                return TRACE_ERR_NULL_TRACE;
     2736        }
     2737        /*assert(str);*/
     2738        if (!str) {
     2739                trace_set_err(trace, TRACE_ERR_CONFIG, "NULL configuration string passed to trace_set_configuration()");
     2740                return -1;
     2741        }
    25682742
    25692743        if (!trace_is_configurable(trace)) return -1;
     
    26012775
    26022776DLLEXPORT void trace_free_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
    2603         assert(packet);
     2777        /*assert(packet);*/
     2778        if (!packet) {
     2779                trace_set_err(libtrace, TRACE_ERR_NULL_PACKET,
     2780                        "NULL packet passed to trace_free_packet()");
     2781                return;
     2782        }
    26042783        /* Always release any resources this might be holding */
    26052784        trace_fin_packet(packet);
Note: See TracChangeset for help on using the changeset viewer.