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)) {
76 _writeUInt(TRACE_VERSION);
82 Writer::_write(const void *sBuffer, size_t dwBytesToWrite) {
83 m_file->write(sBuffer, dwBytesToWrite);
87 Writer::_writeByte(char c) {
92 Writer::_writeUInt(unsigned long long value) {
93 char buf[2 * sizeof value];
98 assert(len < sizeof buf);
99 buf[len] = 0x80 | (value & 0x7f);
105 buf[len - 1] &= 0x7f;
111 Writer::_writeFloat(float value) {
112 assert(sizeof value == 4);
113 _write((const char *)&value, sizeof value);
117 Writer::_writeDouble(double value) {
118 assert(sizeof value == 8);
119 _write((const char *)&value, sizeof value);
123 Writer::_writeString(const char *str) {
124 size_t len = strlen(str);
129 inline bool lookup(std::vector<bool> &map, size_t index) {
130 if (index >= map.size()) {
131 map.resize(index + 1);
138 void Writer::writeBacktrace(std::vector<RawStackFrame> backtrace) {
140 for (int i = 0; i < backtrace.size(); i++) {
142 if (backtrace[i].module != NULL) {
143 beginStackFrameModule();
144 writeString(backtrace[i].module);
145 endStackFrameModule();
147 if (backtrace[i].function != NULL) {
148 beginStackFrameFunction();
149 writeString(backtrace[i].function);
150 endStackFrameFunction();
152 if (backtrace[i].filename != NULL) {
153 beginStackFrameFilename();
154 writeString(backtrace[i].filename);
155 endStackFrameFilename();
157 if (backtrace[i].linenumber != NULL) {
158 beginStackFrameLinenumber();
159 writeString(backtrace[i].linenumber);
160 endStackFrameLinenumber();
162 if (backtrace[i].offset != NULL) {
163 beginStackFrameOffset();
164 writeString(backtrace[i].offset);
165 endStackFrameOffset();
171 void Writer::beginBacktrace(void ) {
172 _writeByte(trace::CALL_BACKTRACE);
175 void Writer::endBacktrace(void ) {
176 _writeByte(trace::CALL_BACKTRACE_END);
179 void Writer::beginStackFrame(void ) {
180 _writeByte(trace::CALL_BACKTRACE_FRAME);
183 void Writer::beginStackFrameModule(void ) {
184 _writeByte(trace::CALL_BACKTRACE_MODULE);
187 void Writer::beginStackFrameFunction(void ) {
188 _writeByte(trace::CALL_BACKTRACE_FUNCTION);
191 void Writer::beginStackFrameFilename(void ) {
192 _writeByte(trace::CALL_BACKTRACE_FILENAME);
195 void Writer::beginStackFrameLinenumber(void ) {
196 _writeByte(trace::CALL_BACKTRACE_LINENUMBER);
199 void Writer::beginStackFrameOffset(void ) {
200 _writeByte(trace::CALL_BACKTRACE_OFFSET);
203 unsigned Writer::beginEnter(FunctionSig *sig, unsigned thread_id) {
204 _writeByte(trace::EVENT_ENTER);
205 _writeUInt(thread_id);
207 if (!lookup(functions, sig->id)) {
208 sig->backtrace = backtrace_is_needed(sig->name);
209 _writeString(sig->name);
210 _writeUInt(sig->num_args);
211 for (unsigned i = 0; i < sig->num_args; ++i) {
212 _writeString(sig->arg_names[i]);
214 functions[sig->id] = true;
220 void Writer::endEnter(void) {
221 _writeByte(trace::CALL_END);
224 void Writer::beginLeave(unsigned call) {
225 _writeByte(trace::EVENT_LEAVE);
229 void Writer::endLeave(void) {
230 _writeByte(trace::CALL_END);
233 void Writer::beginArg(unsigned index) {
234 _writeByte(trace::CALL_ARG);
238 void Writer::beginReturn(void) {
239 _writeByte(trace::CALL_RET);
242 void Writer::beginArray(size_t length) {
243 _writeByte(trace::TYPE_ARRAY);
247 void Writer::beginStruct(const StructSig *sig) {
248 _writeByte(trace::TYPE_STRUCT);
250 if (!lookup(structs, sig->id)) {
251 _writeString(sig->name);
252 _writeUInt(sig->num_members);
253 for (unsigned i = 0; i < sig->num_members; ++i) {
254 _writeString(sig->member_names[i]);
256 structs[sig->id] = true;
260 void Writer::beginRepr(void) {
261 _writeByte(trace::TYPE_REPR);
264 void Writer::writeBool(bool value) {
265 _writeByte(value ? trace::TYPE_TRUE : trace::TYPE_FALSE);
268 void Writer::writeSInt(signed long long value) {
270 _writeByte(trace::TYPE_SINT);
273 _writeByte(trace::TYPE_UINT);
278 void Writer::writeUInt(unsigned long long value) {
279 _writeByte(trace::TYPE_UINT);
283 void Writer::writeFloat(float value) {
284 _writeByte(trace::TYPE_FLOAT);
288 void Writer::writeDouble(double value) {
289 _writeByte(trace::TYPE_DOUBLE);
293 void Writer::writeString(const char *str) {
298 _writeByte(trace::TYPE_STRING);
302 void Writer::writeString(const char *str, size_t len) {
307 _writeByte(trace::TYPE_STRING);
312 void Writer::writeWString(const wchar_t *str) {
317 _writeByte(trace::TYPE_STRING);
318 _writeString("<wide-string>");
321 void Writer::writeBlob(const void *data, size_t size) {
326 _writeByte(trace::TYPE_BLOB);
333 void Writer::writeEnum(const EnumSig *sig, signed long long value) {
334 _writeByte(trace::TYPE_ENUM);
336 if (!lookup(enums, sig->id)) {
337 _writeUInt(sig->num_values);
338 for (unsigned i = 0; i < sig->num_values; ++i) {
339 _writeString(sig->values[i].name);
340 writeSInt(sig->values[i].value);
342 enums[sig->id] = true;
347 void Writer::writeBitmask(const BitmaskSig *sig, unsigned long long value) {
348 _writeByte(trace::TYPE_BITMASK);
350 if (!lookup(bitmasks, sig->id)) {
351 _writeUInt(sig->num_flags);
352 for (unsigned i = 0; i < sig->num_flags; ++i) {
353 if (i != 0 && sig->flags[i].value == 0) {
354 os::log("apitrace: warning: sig %s is zero but is not first flag\n", sig->flags[i].name);
356 _writeString(sig->flags[i].name);
357 _writeUInt(sig->flags[i].value);
359 bitmasks[sig->id] = true;
364 void Writer::writeNull(void) {
365 _writeByte(trace::TYPE_NULL);
368 void Writer::writePointer(unsigned long long addr) {
373 _writeByte(trace::TYPE_OPAQUE);
378 } /* namespace trace */