source: lib/format_helper.c @ 264f4469

4.0.1-hotfixescachetimestampsdevelopdpdk-ndagetsilivegetfragoffhelplibtrace4ndag_formatpfringrc-4.0.1rc-4.0.2rc-4.0.3rc-4.0.4ringdecrementfixringperformanceringtimestampfixes
Last change on this file since 264f4469 was 39b37d2, checked in by Daniel Lawson <dlawson@…>, 16 years ago

include "config.h" <- get 64bit goodness back

  • Property mode set to 100644
File size: 4.3 KB
Line 
1/*
2 * This file is part of libtrace
3 *
4 * Copyright (c) 2004 The University of Waikato, Hamilton, New Zealand.
5 * Authors: Daniel Lawson
6 *          Perry Lorier
7 *         
8 * All rights reserved.
9 *
10 * This code has been developed by the University of Waikato WAND
11 * research group. For further information please see http://www.wand.net.nz/
12 *
13 * libtrace is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2 of the License, or
16 * (at your option) any later version.
17 *
18 * libtrace is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21 * GNU General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public License
24 * along with libtrace; if not, write to the Free Software
25 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
26 *
27 * $Id$
28 *
29 */
30
31#include "libtrace.h"
32#include "libtrace_int.h"
33#include "config.h"
34
35#ifdef HAVE_INTTYPES_H
36#  include <inttypes.h>
37#else
38#  error "Can't find inttypes.h - this needs to be fixed"
39#endif
40#include  "format_helper.h"
41
42#include <sys/ioctl.h>
43/*
44int trace_read(struct libtrace_t *libtrace, void *buffer, size_t len) {
45        int numbytes;
46        static short lctr = 0;
47        int rlen;
48        assert(libtrace);
49        assert(len >= 0);
50
51        if (buffer == 0)
52                buffer = malloc(len);
53
54        while(1) {
55                switch(libtrace->sourcetype) {
56                        case DEVICE:
57                                if ((numbytes=read(INPUT.fd,
58                                                                buffer,
59                                                                len)) == -1) {
60                                        perror("read");
61                                        return -1;
62                                }
63                                break;
64                        default:
65#if HAVE_ZLIB
66                                if ((numbytes=gzread(INPUT.file,
67                                                                buffer,
68                                                                len)) == -1) {
69                                        perror("gzread");
70                                        return -1;
71                                }
72#else
73                                if ((numbytes=fread(buffer,len,1,
74                                        INPUT.file)) == 0 ) {
75                                        if(feof(INPUT.file)) {
76                                                return 0;
77                                        }
78                                        if(ferror(INPUT.file)) {
79                                                perror("fread");
80                                                return -1;
81                                        }
82                                        return 0;
83                                }
84#endif
85                }
86                break;
87        }
88        return numbytes;
89
90}
91*/
92
93struct libtrace_eventobj_t trace_event_device(struct libtrace_t *trace, struct libtrace_packet_t *packet) {
94        struct libtrace_eventobj_t event;
95        int data;
96
97        if (packet->trace->format->get_fd) {
98                event.fd = packet->trace->format->get_fd(packet);
99        } else {
100                event.fd = 0;
101        }
102        if (ioctl(event.fd,FIONREAD,&data)==-1) {
103                perror("ioctl(FIONREAD)");
104        }
105        if (data>0) {
106                event.size = trace_read_packet(trace,packet);
107                event.type = TRACE_EVENT_PACKET;
108                return event;
109        }
110        event.type= TRACE_EVENT_IOWAIT;
111        return event;
112}
113
114struct libtrace_eventobj_t trace_event_trace(struct libtrace_t *trace, struct libtrace_packet_t *packet) {
115        struct libtrace_eventobj_t event;
116        double ts;
117        double now;
118        struct timeval stv;
119
120        if (!trace->event.packet.buffer) {
121                trace->event.packet.buffer = malloc(4096);
122                trace->event.packet.size=
123                        trace_read_packet(trace,packet);
124                event.size = trace->event.packet.size;
125                if (trace->event.packet.size > 0 ) {
126                        memcpy(trace->event.packet.buffer,
127                                        packet->buffer,
128                                        trace->event.packet.size);
129                } else {
130                        // return here, the test for
131                        // event.size will sort out the error
132                        event.type = TRACE_EVENT_PACKET;
133                        return event;
134                }
135        }
136
137        ts=trace_get_seconds(packet);
138        if (trace->event.tdelta!=0) {
139                // Get the adjusted current time
140                gettimeofday(&stv, NULL);
141                now = stv.tv_sec + 
142                        ((double)stv.tv_usec / 1000000.0);
143                // adjust for trace delta
144                now -= trace->event.tdelta; 
145
146                //if the trace timestamp is still in the
147                //future, return a SLEEP event,
148                //otherwise fire the packet
149                if (ts > now) {
150                        event.seconds = ts - 
151                                trace->event.trace_last_ts;
152                        event.type = TRACE_EVENT_SLEEP;
153                        return event;
154                }
155        } else {
156                gettimeofday(&stv, NULL);
157                // work out the difference between the
158                // start of trace replay, and the first
159                // packet in the trace
160                trace->event.tdelta = stv.tv_sec + 
161                        ((double)stv.tv_usec / 1000000.0);
162                trace->event.tdelta -= ts;
163        }
164
165        // This is the first packet, so just fire away.
166        packet->size = trace->event.packet.size;
167        memcpy(packet->buffer,
168                        trace->event.packet.buffer,
169                        trace->event.packet.size);
170        free(trace->event.packet.buffer);
171        trace->event.packet.buffer = 0;
172        event.type = TRACE_EVENT_PACKET;
173
174        trace->event.trace_last_ts = ts;
175
176        return event;
177       
178}
Note: See TracBrowser for help on using the repository browser.