[Libevent-users] Assertion error + Segmentation Fault

[Sherif Fanous]

Hi

I am using libevent 2.0.4 alpha in my C application.

The below snapshot of my code occasionally encounters the following 2
problems


   1. [err] event.c:1961: Assertion !(ev->ev_flags & ~EVLIST_ALL) failed in
   event_del_internal
   Aborted
   2. Segmentation Fault. I've traced down that it occurs in
   the event_base_loop call

In a nutshell, I have a linked list of servers. I loop through every server,
if I'm connected to that server then I create an event for the socket. I
then run the event loop with a timeout. I use the timeout to break out of
the event loop and check if the termination condition has been encountered
in another thread. I also run the event loop with EVLOOP_ONCE to break out
of the loop as soon as 1 event triggers to re-evaluate the linked list of
servers (new connections established, current connections terminated, ...)

When I break of the event loop, I delete the events and free them.

Can anyone please tell me what I'm doing wrong here? Is it an internal
libevent problem, or is my code messing up somewhere?

Thanks

Cheers

    while (!do_terminate) {

        int number_of_servers;
        struct server **servers_array;
        struct event **events;

        number_of_servers = linked_list_to_array(servers, (void ***) &
servers_array, SERVER_NODE, sizeof (struct server *));
        events = (struct event **) malloc(number_of_servers * sizeof (struct
event *));

        int i;
        int number_of_events_added;

        number_of_events_added = 0;

        for (i = 0; i < number_of_servers; i++) {
            struct server *server;

            server = servers_array[i];
            pthread_rwlock_rdlock(&(server->lock));
            if (server->is_socket_connected) {
                struct
client_connector_receive_incoming_packet_callback_arguments
*client_connector_receive_incoming_packet_callback_arguments;

                client_connector_receive_incoming_packet_callback_arguments
= (struct client_connector_receive_incoming_packet_callback_arguments *)
malloc(sizeof (struct
client_connector_receive_incoming_packet_callback_arguments));

 client_connector_receive_incoming_packet_callback_arguments->server =
server;

 
client_connector_receive_incoming_packet_callback_arguments->client_connector_receive_queue
= client_connector_receive_queue;

 client_connector_receive_incoming_packet_callback_arguments->dump_log_queue
= dump_log_queue;

                events[i] = event_new(event_base, server->socket_descriptor,
EV_READ, client_connector_receive_incoming_packet_callback,
client_connector_receive_incoming_packet_callback_arguments);
                event_add(events[i], NULL);

                number_of_events_added++;
            }
            pthread_rwlock_unlock(&(server->lock));
        }

        if (number_of_events_added) {
            struct timeval timeout;

            timeout.tv_sec = DEFAULT_TIMEOUT_SECONDS;
            timeout.tv_usec = DEFAULT_TIMEOUT_MICRO_SECONDS;

            event_base_loopexit(event_base, &timeout);

            event_base_loop(event_base, EVLOOP_ONCE);

            for (i = 0; i < number_of_servers; i++) {
                event_del(events[i]);
                event_free(events[i]);
            }

            if (events) {
                free(events);
                events = NULL;
            }
        }
        else
            sleep(DEFAULT_TIMEOUT_SECONDS);

        pthread_mutex_lock(do_terminate_lock);
        do_terminate =
*(client_connector_receive_incoming_packets_arguments->do_terminate);
        pthread_mutex_unlock(do_terminate_lock);
}