1 /**************************************************************************
3 * Copyright 2007-2009 VMware, Inc.
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 **************************************************************************/
35 #include "trace_file.hpp"
36 #include "trace_writer.hpp"
37 #include "trace_format.hpp"
38 #include "trace_backtrace.hpp"
46 m_file = File::createSnappy();
63 Writer::open(const char *filename) {
66 if (!m_file->open(filename, File::Write)) {
77 _writeUInt(TRACE_VERSION);
83 Writer::_write(const void *sBuffer, size_t dwBytesToWrite) {
84 m_file->write(sBuffer, dwBytesToWrite);
88 Writer::_writeByte(char c) {
93 Writer::_writeUInt(unsigned long long value) {
94 char buf[2 * sizeof value];
99 assert(len < sizeof buf);
100 buf[len] = 0x80 | (value & 0x7f);
106 buf[len - 1] &= 0x7f;
112 Writer::_writeFloat(float value) {
113 assert(sizeof value == 4);
114 _write((const char *)&value, sizeof value);
118 Writer::_writeDouble(double value) {
119 assert(sizeof value == 8);
120 _write((const char *)&value, sizeof value);
124 Writer::_writeString(const char *str) {
125 size_t len = strlen(str);
130 inline bool lookup(std::vector<bool> &map, size_t index) {
131 if (index >= map.size()) {
132 map.resize(index + 1);
139 void Writer::beginBacktrace(unsigned num_frames) {
141 _writeByte(trace::CALL_BACKTRACE);
142 _writeUInt(num_frames);
146 void Writer::writeStackFrame(const RawStackFrame *frame) {
147 _writeUInt(frame->id);
148 if (!lookup(frames, frame->id)) {
149 if (frame->module != NULL) {
150 _writeByte(trace::BACKTRACE_MODULE);
151 _writeString(frame->module);
153 if (frame->function != NULL) {
154 _writeByte(trace::BACKTRACE_FUNCTION);
155 _writeString(frame->function);
157 if (frame->filename != NULL) {
158 _writeByte(trace::BACKTRACE_FILENAME);
159 _writeString(frame->filename);
161 if (frame->linenumber >= 0) {
162 _writeByte(trace::BACKTRACE_LINENUMBER);
163 _writeUInt(frame->linenumber);
165 if (frame->offset >= 0) {
166 _writeByte(trace::BACKTRACE_OFFSET);
167 _writeUInt(frame->offset);
169 _writeByte(trace::BACKTRACE_END);
170 frames[frame->id] = true;
174 unsigned Writer::beginEnter(const FunctionSig *sig, unsigned thread_id) {
175 _writeByte(trace::EVENT_ENTER);
176 _writeUInt(thread_id);
178 if (!lookup(functions, sig->id)) {
179 _writeString(sig->name);
180 _writeUInt(sig->num_args);
181 for (unsigned i = 0; i < sig->num_args; ++i) {
182 _writeString(sig->arg_names[i]);
184 functions[sig->id] = true;
190 void Writer::endEnter(void) {
191 _writeByte(trace::CALL_END);
194 void Writer::beginLeave(unsigned call) {
195 _writeByte(trace::EVENT_LEAVE);
199 void Writer::endLeave(void) {
200 _writeByte(trace::CALL_END);
203 void Writer::beginArg(unsigned index) {
204 _writeByte(trace::CALL_ARG);
208 void Writer::beginReturn(void) {
209 _writeByte(trace::CALL_RET);
212 void Writer::beginArray(size_t length) {
213 _writeByte(trace::TYPE_ARRAY);
217 void Writer::beginStruct(const StructSig *sig) {
218 _writeByte(trace::TYPE_STRUCT);
220 if (!lookup(structs, sig->id)) {
221 _writeString(sig->name);
222 _writeUInt(sig->num_members);
223 for (unsigned i = 0; i < sig->num_members; ++i) {
224 _writeString(sig->member_names[i]);
226 structs[sig->id] = true;
230 void Writer::beginRepr(void) {
231 _writeByte(trace::TYPE_REPR);
234 void Writer::writeBool(bool value) {
235 _writeByte(value ? trace::TYPE_TRUE : trace::TYPE_FALSE);
238 void Writer::writeSInt(signed long long value) {
240 _writeByte(trace::TYPE_SINT);
243 _writeByte(trace::TYPE_UINT);
248 void Writer::writeUInt(unsigned long long value) {
249 _writeByte(trace::TYPE_UINT);
253 void Writer::writeFloat(float value) {
254 _writeByte(trace::TYPE_FLOAT);
258 void Writer::writeDouble(double value) {
259 _writeByte(trace::TYPE_DOUBLE);
263 void Writer::writeString(const char *str) {
268 _writeByte(trace::TYPE_STRING);
272 void Writer::writeString(const char *str, size_t len) {
277 _writeByte(trace::TYPE_STRING);
282 void Writer::writeWString(const wchar_t *str) {
287 _writeByte(trace::TYPE_STRING);
288 _writeString("<wide-string>");
291 void Writer::writeBlob(const void *data, size_t size) {
296 _writeByte(trace::TYPE_BLOB);
303 void Writer::writeEnum(const EnumSig *sig, signed long long value) {
304 _writeByte(trace::TYPE_ENUM);
306 if (!lookup(enums, sig->id)) {
307 _writeUInt(sig->num_values);
308 for (unsigned i = 0; i < sig->num_values; ++i) {
309 _writeString(sig->values[i].name);
310 writeSInt(sig->values[i].value);
312 enums[sig->id] = true;
317 void Writer::writeBitmask(const BitmaskSig *sig, unsigned long long value) {
318 _writeByte(trace::TYPE_BITMASK);
320 if (!lookup(bitmasks, sig->id)) {
321 _writeUInt(sig->num_flags);
322 for (unsigned i = 0; i < sig->num_flags; ++i) {
323 if (i != 0 && sig->flags[i].value == 0) {
324 os::log("apitrace: warning: sig %s is zero but is not first flag\n", sig->flags[i].name);
326 _writeString(sig->flags[i].name);
327 _writeUInt(sig->flags[i].value);
329 bitmasks[sig->id] = true;
334 void Writer::writeNull(void) {
335 _writeByte(trace::TYPE_NULL);
338 void Writer::writePointer(unsigned long long addr) {
343 _writeByte(trace::TYPE_OPAQUE);
348 } /* namespace trace */