source: lib/format_helper.c @ 9c6aa95

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

cleaned up after compiling with -Wall -W

  • Property mode set to 100644
File size: 4.4 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#include <stdlib.h>
36#include <stdio.h>
37#include <string.h>
38#ifdef HAVE_INTTYPES_H
39#  include <inttypes.h>
40#else
41#  error "Can't find inttypes.h - this needs to be fixed"
42#endif
43#include  "format_helper.h"
44
45#include <sys/ioctl.h>
46/*
47int trace_read(struct libtrace_t *libtrace, void *buffer, size_t len) {
48        int numbytes;
49        static short lctr = 0;
50        int rlen;
51        assert(libtrace);
52        assert(len >= 0);
53
54        if (buffer == 0)
55                buffer = malloc(len);
56
57        while(1) {
58                switch(libtrace->sourcetype) {
59                        case DEVICE:
60                                if ((numbytes=read(INPUT.fd,
61                                                                buffer,
62                                                                len)) == -1) {
63                                        perror("read");
64                                        return -1;
65                                }
66                                break;
67                        default:
68#if HAVE_ZLIB
69                                if ((numbytes=gzread(INPUT.file,
70                                                                buffer,
71                                                                len)) == -1) {
72                                        perror("gzread");
73                                        return -1;
74                                }
75#else
76                                if ((numbytes=fread(buffer,len,1,
77                                        INPUT.file)) == 0 ) {
78                                        if(feof(INPUT.file)) {
79                                                return 0;
80                                        }
81                                        if(ferror(INPUT.file)) {
82                                                perror("fread");
83                                                return -1;
84                                        }
85                                        return 0;
86                                }
87#endif
88                }
89                break;
90        }
91        return numbytes;
92
93}
94*/
95
96struct libtrace_eventobj_t trace_event_device(struct libtrace_t *trace, struct libtrace_packet_t *packet) {
97        struct libtrace_eventobj_t event;
98        int data;
99
100        if (packet->trace->format->get_fd) {
101                event.fd = packet->trace->format->get_fd(packet);
102        } else {
103                event.fd = 0;
104        }
105        if (ioctl(event.fd,FIONREAD,&data)==-1) {
106                perror("ioctl(FIONREAD)");
107        }
108        if (data>0) {
109                event.size = trace_read_packet(trace,packet);
110                event.type = TRACE_EVENT_PACKET;
111                return event;
112        }
113        event.type= TRACE_EVENT_IOWAIT;
114        return event;
115}
116
117struct libtrace_eventobj_t trace_event_trace(struct libtrace_t *trace, struct libtrace_packet_t *packet) {
118        struct libtrace_eventobj_t event;
119        double ts;
120        double now;
121        struct timeval stv;
122
123        if (!trace->event.packet.buffer) {
124                trace->event.packet.buffer = (void *)malloc(4096);
125                trace->event.packet.size=
126                        trace_read_packet(trace,packet);
127                event.size = trace->event.packet.size;
128                if (trace->event.packet.size > 0 ) {
129                        memcpy(trace->event.packet.buffer,
130                                        packet->buffer,
131                                        trace->event.packet.size);
132                } else {
133                        // return here, the test for
134                        // event.size will sort out the error
135                        event.type = TRACE_EVENT_PACKET;
136                        return event;
137                }
138        }
139
140        ts=trace_get_seconds(packet);
141        if (trace->event.tdelta!=0) {
142                // Get the adjusted current time
143                gettimeofday(&stv, NULL);
144                now = stv.tv_sec + 
145                        ((double)stv.tv_usec / 1000000.0);
146                // adjust for trace delta
147                now -= trace->event.tdelta; 
148
149                //if the trace timestamp is still in the
150                //future, return a SLEEP event,
151                //otherwise fire the packet
152                if (ts > now) {
153                        event.seconds = ts - 
154                                trace->event.trace_last_ts;
155                        event.type = TRACE_EVENT_SLEEP;
156                        return event;
157                }
158        } else {
159                gettimeofday(&stv, NULL);
160                // work out the difference between the
161                // start of trace replay, and the first
162                // packet in the trace
163                trace->event.tdelta = stv.tv_sec + 
164                        ((double)stv.tv_usec / 1000000.0);
165                trace->event.tdelta -= ts;
166        }
167
168        // This is the first packet, so just fire away.
169        packet->size = trace->event.packet.size;
170        memcpy(packet->buffer,
171                        trace->event.packet.buffer,
172                        trace->event.packet.size);
173        free(trace->event.packet.buffer);
174        trace->event.packet.buffer = 0;
175        event.type = TRACE_EVENT_PACKET;
176
177        trace->event.trace_last_ts = ts;
178
179        return event;
180       
181}
Note: See TracBrowser for help on using the repository browser.