1 /************************************************************************** 2 * 3 * Copyright 2008 VMware, Inc. 4 * All Rights Reserved. 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a 7 * copy of this software and associated documentation files (the 8 * "Software"), to deal in the Software without restriction, including 9 * without limitation the rights to use, copy, modify, merge, publish, 10 * distribute, sub license, and/or sell copies of the Software, and to 11 * permit persons to whom the Software is furnished to do so, subject to 12 * the following conditions: 13 * 14 * The above copyright notice and this permission notice (including the 15 * next paragraph) shall be included in all copies or substantial portions 16 * of the Software. 17 * 18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. 21 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR 22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 25 * 26 **************************************************************************/ 27 28 /** 29 * @file 30 * Trace data dumping primitives. 31 */ 32 33 #ifndef TR_DUMP_H 34 #define TR_DUMP_H 35 36 37 #include "pipe/p_compiler.h" 38 #include "pipe/p_format.h" 39 40 struct pipe_resource; 41 struct pipe_surface; 42 struct pipe_transfer; 43 struct pipe_box; 44 45 /* 46 * Low level dumping controls. 47 * 48 * Opening the trace file and checking if that is opened. 49 */ 50 bool trace_dump_trace_begin(void); 51 bool trace_dump_trace_enabled(void); 52 void trace_dump_trace_flush(void); 53 54 /* 55 * Lock and unlock the call mutex. 56 * 57 * It used by the none locked version of dumping control 58 * and begin/end call dump functions. 59 * 60 * Begin takes the lock while end unlocks it. Use the _locked 61 * version to avoid locking/unlocking it. 62 */ 63 void trace_dump_call_lock(void); 64 void trace_dump_call_unlock(void); 65 66 /* 67 * High level dumping control. 68 */ 69 void trace_dumping_start_locked(void); 70 void trace_dumping_stop_locked(void); 71 bool trace_dumping_enabled_locked(void); 72 void trace_dumping_start(void); 73 void trace_dumping_stop(void); 74 bool trace_dumping_enabled(void); 75 76 void trace_dump_call_begin_locked(const char *klass, const char *method); 77 void trace_dump_call_end_locked(void); 78 void trace_dump_call_begin(const char *klass, const char *method); 79 void trace_dump_call_end(void); 80 81 void trace_dump_arg_begin(const char *name); 82 void trace_dump_arg_end(void); 83 void trace_dump_ret_begin(void); 84 void trace_dump_ret_end(void); 85 void trace_dump_bool(int value); 86 void trace_dump_int(long long int value); 87 void trace_dump_uint(long long unsigned value); 88 void trace_dump_float(double value); 89 void trace_dump_bytes(const void *data, size_t size); 90 void trace_dump_box_bytes(const void *data, 91 struct pipe_resource *resource, 92 const struct pipe_box *box, 93 unsigned stride, 94 unsigned slice_stride); 95 void trace_dump_string(const char *str); 96 void trace_dump_enum(const char *value); 97 void trace_dump_array_begin(void); 98 void trace_dump_array_end(void); 99 void trace_dump_elem_begin(void); 100 void trace_dump_elem_end(void); 101 void trace_dump_struct_begin(const char *name); 102 void trace_dump_struct_end(void); 103 void trace_dump_member_begin(const char *name); 104 void trace_dump_member_end(void); 105 void trace_dump_null(void); 106 void trace_dump_ptr(const void *value); 107 /* will turn a wrapped object into the real one and dump ptr */ 108 void trace_dump_surface_ptr(struct pipe_surface *_surface); 109 void trace_dump_transfer_ptr(struct pipe_transfer *_transfer); 110 111 /* 112 * Code saving macros. 113 */ 114 115 #define trace_dump_arg(_type, _arg) \ 116 do { \ 117 trace_dump_arg_begin(#_arg); \ 118 trace_dump_##_type(_arg); \ 119 trace_dump_arg_end(); \ 120 } while(0) 121 122 #define trace_dump_arg_struct(_type, _arg) \ 123 do { \ 124 trace_dump_arg_begin(#_arg); \ 125 trace_dump_##_type(&_arg); \ 126 trace_dump_arg_end(); \ 127 } while(0) 128 129 #define trace_dump_ret(_type, _arg) \ 130 do { \ 131 trace_dump_ret_begin(); \ 132 trace_dump_##_type(_arg); \ 133 trace_dump_ret_end(); \ 134 } while(0) 135 136 #define trace_dump_array(_type, _obj, _size) \ 137 do { \ 138 if (_obj) { \ 139 size_t idx; \ 140 trace_dump_array_begin(); \ 141 for(idx = 0; idx < (_size); ++idx) { \ 142 trace_dump_elem_begin(); \ 143 trace_dump_##_type((_obj)[idx]); \ 144 trace_dump_elem_end(); \ 145 } \ 146 trace_dump_array_end(); \ 147 } else { \ 148 trace_dump_null(); \ 149 } \ 150 } while(0) 151 152 #define trace_dump_struct_array(_type, _obj, _size) \ 153 do { \ 154 if (_obj) { \ 155 size_t idx; \ 156 trace_dump_array_begin(); \ 157 for(idx = 0; idx < (_size); ++idx) { \ 158 trace_dump_elem_begin(); \ 159 trace_dump_##_type(&(_obj)[idx]); \ 160 trace_dump_elem_end(); \ 161 } \ 162 trace_dump_array_end(); \ 163 } else { \ 164 trace_dump_null(); \ 165 } \ 166 } while(0) 167 168 #define trace_dump_member(_type, _obj, _member) \ 169 do { \ 170 trace_dump_member_begin(#_member); \ 171 trace_dump_##_type((_obj)->_member); \ 172 trace_dump_member_end(); \ 173 } while(0) 174 175 #define trace_dump_arg_array(_type, _arg, _size) \ 176 do { \ 177 trace_dump_arg_begin(#_arg); \ 178 trace_dump_array(_type, _arg, _size); \ 179 trace_dump_arg_end(); \ 180 } while(0) 181 182 #define trace_dump_member_array(_type, _obj, _member) \ 183 do { \ 184 trace_dump_member_begin(#_member); \ 185 trace_dump_array(_type, (_obj)->_member, sizeof((_obj)->_member)/sizeof((_obj)->_member[0])); \ 186 trace_dump_member_end(); \ 187 } while(0) 188 189 190 #endif /* TR_DUMP_H */ 191