Changeset aeee9db


Ignore:
Timestamp:
05/02/06 17:19:34 (15 years ago)
Author:
Shane Alcock <salcock@…>
Branches:
4.0.1-hotfixes, cachetimestamps, develop, dpdk-ndag, etsilive, getfragoff, help, libtrace4, master, ndag_format, pfring, rc-4.0.1, rc-4.0.2, rc-4.0.3, rc-4.0.4, ringdecrementfix, ringperformance, ringtimestampfixes
Children:
ef69a05
Parents:
62987bb
Message:

Added non_blocking read support for wag devices
Created trace_event_wag to bypass the lack of FIONREAD ioctl
Fixed bug where packet->size wasn't being set when wag device reads a packet

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/format_wag.c

    re6d963c raeee9db  
    200200}
    201201
    202 static int wag_read(libtrace_t *libtrace, void *buffer, size_t len) {
     202static int wag_read(libtrace_t *libtrace, void *buffer, size_t len,
     203                int block) {
    203204        size_t framesize;
    204205        char *buf_ptr = (char *)buffer;
    205206        int to_read = 0;
    206207        uint16_t magic = 0;
    207 
     208        long fd_flags;
     209       
    208210        assert(libtrace);
    209211
    210212        to_read = sizeof(struct frame_t);
    211213
     214        fd_flags = fcntl(INPUT.fd, F_GETFL);
     215        if (fd_flags == -1) {
     216                /* TODO: Replace with better libtrace-style
     217                 * error handling later */
     218                perror("Could not get fd flags");
     219                return 0;
     220        }
     221       
     222       
     223       
     224        if (!block) {
     225                if (fcntl(INPUT.fd, F_SETFL, fd_flags | O_NONBLOCK) == -1) {
     226                        perror("Could not set fd flags");
     227                        return 0;
     228                }
     229        }
     230        else {
     231                if (fd_flags & O_NONBLOCK) {
     232                        fd_flags &= ~O_NONBLOCK;
     233                        if (fcntl(INPUT.fd, F_SETFL, fd_flags) == -1) {
     234                                perror("Could not set fd flags");
     235                                return 0;
     236                        }
     237                }
     238        }
     239
     240        /* I'm not sure if wag has a memory hole which we can use for
     241         * zero-copy - something to add in later, I guess */
     242       
    212243        while (to_read>0) {
    213           int ret=read(INPUT.fd,buf_ptr,to_read);
    214 
    215           if (ret == -1) {
    216             if (errno == EINTR || errno==EAGAIN)
    217               continue;
    218 
    219             trace_set_err(libtrace,errno,"read(%s)",libtrace->uridata);
    220             return -1;
    221           }
    222 
    223           assert(ret>0);
    224 
    225           to_read = to_read - ret;
    226           buf_ptr = buf_ptr + ret;
     244                int ret=read(INPUT.fd,buf_ptr,to_read);
     245
     246                if (ret == -1) {
     247                        if (errno == EINTR)
     248                                continue;
     249                       
     250                        if (errno == EAGAIN) {
     251                                trace_set_err(libtrace, EAGAIN, "EAGAIN");
     252                                return -1;
     253                        }
     254           
     255                        trace_set_err(libtrace,errno,
     256                                        "read(%s)",libtrace->uridata);
     257                        return -1;
     258                }
     259
     260                assert(ret>0);
     261
     262                to_read = to_read - ret;
     263                buf_ptr = buf_ptr + ret;
    227264        }
    228265
     
    238275
    239276        /* We should deal.  this is called "snapping", but we don't yet */
    240         assert(framesize>len);
     277        assert(framesize<=len);
    241278
    242279        buf_ptr = (void*)((char*)buffer + sizeof (struct frame_t));
     
    244281       
    245282        while (to_read>0) {
    246           int ret=read(INPUT.fd,buf_ptr,to_read);
    247 
    248           if (ret == -1) {
    249             if (errno == EINTR || errno==EAGAIN)
    250               continue;
    251             trace_set_err(libtrace,errno,"read(%s)",libtrace->uridata);
    252             return -1;
    253           }
    254 
    255           to_read = to_read - ret;
    256           buf_ptr = buf_ptr + ret;
     283                int ret=read(INPUT.fd,buf_ptr,to_read);
     284
     285                if (ret == -1) {
     286                        if (errno == EINTR)
     287                                continue;
     288                        if (errno == EAGAIN) {
     289                                /* What happens to the frame header?! */
     290                                trace_set_err(libtrace, EAGAIN, "EAGAIN");
     291                                return -1;
     292                        }
     293                        trace_set_err(libtrace,errno,"read(%s)",
     294                                        libtrace->uridata);
     295                        return -1;
     296                }
     297
     298                to_read = to_read - ret;
     299                buf_ptr = buf_ptr + ret;
    257300        }
    258301        return framesize;
     
    260303
    261304
    262 static int wag_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
     305static int wag_read_packet_versatile(libtrace_t *libtrace, libtrace_packet_t *packet, int block_flag) {
    263306        int numbytes;
    264307       
     
    272315        packet->type = RT_DATA_WAG;
    273316       
    274         if ((numbytes = wag_read(libtrace, (void *)packet->buffer, RP_BUFSIZE)) <= 0) {
     317        if ((numbytes = wag_read(libtrace, (void *)packet->buffer,
     318                                        RP_BUFSIZE, block_flag)) <= 0) {
    275319           
    276320                return numbytes;
     
    280324        packet->header = packet->buffer;
    281325        packet->payload=(char*)packet->buffer+trace_get_framing_length(packet);
     326        packet->size = trace_get_framing_length(packet) + trace_get_capture_length(packet);
    282327        return numbytes;
     328}
     329
     330static int wag_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
     331        return wag_read_packet_versatile(libtrace, packet, 1);
    283332}
    284333
     
    399448}
    400449
     450struct libtrace_eventobj_t trace_event_wag(libtrace_t *trace, libtrace_packet_t *packet) {
     451        struct libtrace_eventobj_t event = {0,0,0.0,0};
     452        libtrace_err_t read_err;
     453
     454        assert(trace);
     455        assert(packet);
     456
     457        /* We could probably just call get_fd here */
     458        if (trace->format->get_fd) {
     459                event.fd = trace->format->get_fd(trace);
     460        } else {
     461                event.fd = 0;
     462        }
     463       
     464        event.size = wag_read_packet_versatile(trace, packet, 0);
     465        if (event.size == -1) {
     466                read_err = trace_get_err(trace);
     467                if (read_err.err_num = EAGAIN) {
     468                        event.type = TRACE_EVENT_IOWAIT;
     469                }
     470                else {
     471                        printf("Packet error\n");
     472                        event.type = TRACE_EVENT_PACKET;
     473                }
     474        } else if (event.size == 0) {
     475                event.type = TRACE_EVENT_TERMINATE;
     476        } else {
     477                event.type = TRACE_EVENT_PACKET;
     478        }
     479
     480        return event;
     481}
     482       
    401483static void wag_help() {
    402484        printf("wag format module: $Revision$\n");
     
    457539        NULL,                           /* set_capture_length */
    458540        wag_get_fd,                     /* get_fd */
    459         trace_event_device,             /* trace_event */
     541        trace_event_wag,                /* trace_event */
    460542        wag_help,                       /* help */
    461543        NULL                            /* next pointer */
Note: See TracChangeset for help on using the changeset viewer.