]>
Commit | Line | Data |
---|---|---|
3f728236 ZW |
1 | /* |
2 | * Copyright © 2011-2016 Intel Corporation | |
3 | * | |
4 | * Permission is hereby granted, free of charge, to any person obtaining a | |
5 | * copy of this software and associated documentation files (the "Software"), | |
6 | * to deal in the Software without restriction, including without limitation | |
7 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, | |
8 | * and/or sell copies of the Software, and to permit persons to whom the | |
9 | * Software is furnished to do so, subject to the following conditions: | |
10 | * | |
11 | * The above copyright notice and this permission notice (including the next | |
12 | * paragraph) shall be included in all copies or substantial portions of the | |
13 | * Software. | |
14 | * | |
15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
16 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
17 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
18 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
19 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING | |
20 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS | |
21 | * IN THE SOFTWARE. | |
22 | * | |
23 | * Authors: | |
24 | * Jike Song <jike.song@intel.com> | |
25 | * | |
26 | * Contributors: | |
27 | * Zhi Wang <zhi.a.wang@intel.com> | |
28 | * | |
29 | */ | |
30 | ||
31 | #if !defined(_GVT_TRACE_H_) || defined(TRACE_HEADER_MULTI_READ) | |
32 | #define _GVT_TRACE_H_ | |
33 | ||
34 | #include <linux/types.h> | |
35 | #include <linux/stringify.h> | |
36 | #include <linux/tracepoint.h> | |
37 | #include <asm/tsc.h> | |
38 | ||
39 | #undef TRACE_SYSTEM | |
40 | #define TRACE_SYSTEM gvt | |
41 | ||
2707e444 ZW |
42 | TRACE_EVENT(spt_alloc, |
43 | TP_PROTO(int id, void *spt, int type, unsigned long mfn, | |
44 | unsigned long gpt_gfn), | |
45 | ||
46 | TP_ARGS(id, spt, type, mfn, gpt_gfn), | |
47 | ||
48 | TP_STRUCT__entry( | |
49 | __field(int, id) | |
50 | __field(void *, spt) | |
51 | __field(int, type) | |
52 | __field(unsigned long, mfn) | |
53 | __field(unsigned long, gpt_gfn) | |
54 | ), | |
55 | ||
56 | TP_fast_assign( | |
57 | __entry->id = id; | |
58 | __entry->spt = spt; | |
59 | __entry->type = type; | |
60 | __entry->mfn = mfn; | |
61 | __entry->gpt_gfn = gpt_gfn; | |
62 | ), | |
63 | ||
64 | TP_printk("VM%d [alloc] spt %p type %d mfn 0x%lx gfn 0x%lx\n", | |
65 | __entry->id, | |
66 | __entry->spt, | |
67 | __entry->type, | |
68 | __entry->mfn, | |
69 | __entry->gpt_gfn) | |
70 | ); | |
71 | ||
72 | TRACE_EVENT(spt_free, | |
73 | TP_PROTO(int id, void *spt, int type), | |
74 | ||
75 | TP_ARGS(id, spt, type), | |
76 | ||
77 | TP_STRUCT__entry( | |
78 | __field(int, id) | |
79 | __field(void *, spt) | |
80 | __field(int, type) | |
81 | ), | |
82 | ||
83 | TP_fast_assign( | |
84 | __entry->id = id; | |
85 | __entry->spt = spt; | |
86 | __entry->type = type; | |
87 | ), | |
88 | ||
89 | TP_printk("VM%u [free] spt %p type %d\n", | |
90 | __entry->id, | |
91 | __entry->spt, | |
92 | __entry->type) | |
93 | ); | |
94 | ||
95 | #define MAX_BUF_LEN 256 | |
96 | ||
97 | TRACE_EVENT(gma_index, | |
98 | TP_PROTO(const char *prefix, unsigned long gma, | |
99 | unsigned long index), | |
100 | ||
101 | TP_ARGS(prefix, gma, index), | |
102 | ||
103 | TP_STRUCT__entry( | |
104 | __array(char, buf, MAX_BUF_LEN) | |
105 | ), | |
106 | ||
107 | TP_fast_assign( | |
108 | snprintf(__entry->buf, MAX_BUF_LEN, | |
109 | "%s gma 0x%lx index 0x%lx\n", prefix, gma, index); | |
110 | ), | |
111 | ||
112 | TP_printk("%s", __entry->buf) | |
113 | ); | |
114 | ||
115 | TRACE_EVENT(gma_translate, | |
116 | TP_PROTO(int id, char *type, int ring_id, int pt_level, | |
117 | unsigned long gma, unsigned long gpa), | |
118 | ||
119 | TP_ARGS(id, type, ring_id, pt_level, gma, gpa), | |
120 | ||
121 | TP_STRUCT__entry( | |
122 | __array(char, buf, MAX_BUF_LEN) | |
123 | ), | |
124 | ||
125 | TP_fast_assign( | |
126 | snprintf(__entry->buf, MAX_BUF_LEN, | |
127 | "VM%d %s ring %d pt_level %d gma 0x%lx -> gpa 0x%lx\n", | |
128 | id, type, ring_id, pt_level, gma, gpa); | |
129 | ), | |
130 | ||
131 | TP_printk("%s", __entry->buf) | |
132 | ); | |
133 | ||
134 | TRACE_EVENT(spt_refcount, | |
135 | TP_PROTO(int id, char *action, void *spt, int before, int after), | |
136 | ||
137 | TP_ARGS(id, action, spt, before, after), | |
138 | ||
139 | TP_STRUCT__entry( | |
140 | __array(char, buf, MAX_BUF_LEN) | |
141 | ), | |
142 | ||
143 | TP_fast_assign( | |
144 | snprintf(__entry->buf, MAX_BUF_LEN, | |
145 | "VM%d [%s] spt %p before %d -> after %d\n", | |
146 | id, action, spt, before, after); | |
147 | ), | |
148 | ||
149 | TP_printk("%s", __entry->buf) | |
150 | ); | |
151 | ||
152 | TRACE_EVENT(spt_change, | |
153 | TP_PROTO(int id, char *action, void *spt, unsigned long gfn, | |
154 | int type), | |
155 | ||
156 | TP_ARGS(id, action, spt, gfn, type), | |
157 | ||
158 | TP_STRUCT__entry( | |
159 | __array(char, buf, MAX_BUF_LEN) | |
160 | ), | |
161 | ||
162 | TP_fast_assign( | |
163 | snprintf(__entry->buf, MAX_BUF_LEN, | |
164 | "VM%d [%s] spt %p gfn 0x%lx type %d\n", | |
165 | id, action, spt, gfn, type); | |
166 | ), | |
167 | ||
168 | TP_printk("%s", __entry->buf) | |
169 | ); | |
170 | ||
171 | TRACE_EVENT(gpt_change, | |
172 | TP_PROTO(int id, const char *tag, void *spt, int type, u64 v, | |
173 | unsigned long index), | |
174 | ||
175 | TP_ARGS(id, tag, spt, type, v, index), | |
176 | ||
177 | TP_STRUCT__entry( | |
178 | __array(char, buf, MAX_BUF_LEN) | |
179 | ), | |
180 | ||
181 | TP_fast_assign( | |
182 | snprintf(__entry->buf, MAX_BUF_LEN, | |
183 | "VM%d [%s] spt %p type %d entry 0x%llx index 0x%lx\n", | |
184 | id, tag, spt, type, v, index); | |
185 | ), | |
186 | ||
187 | TP_printk("%s", __entry->buf) | |
188 | ); | |
189 | ||
190 | TRACE_EVENT(oos_change, | |
191 | TP_PROTO(int id, const char *tag, int page_id, void *gpt, int type), | |
192 | ||
193 | TP_ARGS(id, tag, page_id, gpt, type), | |
194 | ||
195 | TP_STRUCT__entry( | |
196 | __array(char, buf, MAX_BUF_LEN) | |
197 | ), | |
198 | ||
199 | TP_fast_assign( | |
200 | snprintf(__entry->buf, MAX_BUF_LEN, | |
201 | "VM%d [oos %s] page id %d gpt %p type %d\n", | |
202 | id, tag, page_id, gpt, type); | |
203 | ), | |
204 | ||
205 | TP_printk("%s", __entry->buf) | |
206 | ); | |
207 | ||
208 | TRACE_EVENT(oos_sync, | |
209 | TP_PROTO(int id, int page_id, void *gpt, int type, u64 v, | |
210 | unsigned long index), | |
211 | ||
212 | TP_ARGS(id, page_id, gpt, type, v, index), | |
213 | ||
214 | TP_STRUCT__entry( | |
215 | __array(char, buf, MAX_BUF_LEN) | |
216 | ), | |
217 | ||
218 | TP_fast_assign( | |
219 | snprintf(__entry->buf, MAX_BUF_LEN, | |
220 | "VM%d [oos sync] page id %d gpt %p type %d entry 0x%llx index 0x%lx\n", | |
221 | id, page_id, gpt, type, v, index); | |
222 | ), | |
223 | ||
224 | TP_printk("%s", __entry->buf) | |
225 | ); | |
226 | ||
be1da707 | 227 | TRACE_EVENT(gvt_command, |
ffc19776 CD |
228 | TP_PROTO(u8 vgpu_id, u8 ring_id, u32 ip_gma, u32 *cmd_va, u32 cmd_len, |
229 | u32 buf_type), | |
230 | ||
231 | TP_ARGS(vgpu_id, ring_id, ip_gma, cmd_va, cmd_len, buf_type), | |
232 | ||
233 | TP_STRUCT__entry( | |
234 | __field(u8, vgpu_id) | |
235 | __field(u8, ring_id) | |
236 | __field(u32, ip_gma) | |
237 | __field(u32, buf_type) | |
238 | __field(u32, cmd_len) | |
239 | __dynamic_array(u32, raw_cmd, cmd_len) | |
240 | ), | |
241 | ||
242 | TP_fast_assign( | |
243 | __entry->vgpu_id = vgpu_id; | |
244 | __entry->ring_id = ring_id; | |
245 | __entry->ip_gma = ip_gma; | |
246 | __entry->buf_type = buf_type; | |
247 | __entry->cmd_len = cmd_len; | |
248 | memcpy(__get_dynamic_array(raw_cmd), cmd_va, cmd_len * sizeof(*cmd_va)); | |
249 | ), | |
250 | ||
be1da707 | 251 | |
ffc19776 CD |
252 | TP_printk("vgpu%d ring %d: buf_type %u, ip_gma %08x, raw cmd %s", |
253 | __entry->vgpu_id, | |
254 | __entry->ring_id, | |
255 | __entry->buf_type, | |
256 | __entry->ip_gma, | |
257 | __print_array(__get_dynamic_array(raw_cmd), __entry->cmd_len, 4)) | |
be1da707 | 258 | ); |
7fb6a7d6 XZ |
259 | |
260 | #define GVT_TEMP_STR_LEN 10 | |
261 | TRACE_EVENT(write_ir, | |
262 | TP_PROTO(int id, char *reg_name, unsigned int reg, unsigned int new_val, | |
263 | unsigned int old_val, bool changed), | |
264 | ||
265 | TP_ARGS(id, reg_name, reg, new_val, old_val, changed), | |
266 | ||
267 | TP_STRUCT__entry( | |
268 | __field(int, id) | |
269 | __array(char, buf, GVT_TEMP_STR_LEN) | |
270 | __field(unsigned int, reg) | |
271 | __field(unsigned int, new_val) | |
272 | __field(unsigned int, old_val) | |
273 | __field(bool, changed) | |
274 | ), | |
275 | ||
276 | TP_fast_assign( | |
277 | __entry->id = id; | |
278 | snprintf(__entry->buf, GVT_TEMP_STR_LEN, "%s", reg_name); | |
279 | __entry->reg = reg; | |
280 | __entry->new_val = new_val; | |
281 | __entry->old_val = old_val; | |
282 | __entry->changed = changed; | |
283 | ), | |
284 | ||
285 | TP_printk("VM%u write [%s] %x, new %08x, old %08x, changed %08x\n", | |
286 | __entry->id, __entry->buf, __entry->reg, __entry->new_val, | |
287 | __entry->old_val, __entry->changed) | |
288 | ); | |
289 | ||
290 | TRACE_EVENT(propagate_event, | |
291 | TP_PROTO(int id, const char *irq_name, int bit), | |
292 | ||
293 | TP_ARGS(id, irq_name, bit), | |
294 | ||
295 | TP_STRUCT__entry( | |
296 | __field(int, id) | |
297 | __array(char, buf, GVT_TEMP_STR_LEN) | |
298 | __field(int, bit) | |
299 | ), | |
300 | ||
301 | TP_fast_assign( | |
302 | __entry->id = id; | |
303 | snprintf(__entry->buf, GVT_TEMP_STR_LEN, "%s", irq_name); | |
304 | __entry->bit = bit; | |
305 | ), | |
306 | ||
307 | TP_printk("Set bit (%d) for (%s) for vgpu (%d)\n", | |
308 | __entry->bit, __entry->buf, __entry->id) | |
309 | ); | |
310 | ||
311 | TRACE_EVENT(inject_msi, | |
312 | TP_PROTO(int id, unsigned int address, unsigned int data), | |
313 | ||
314 | TP_ARGS(id, address, data), | |
315 | ||
316 | TP_STRUCT__entry( | |
317 | __field(int, id) | |
318 | __field(unsigned int, address) | |
319 | __field(unsigned int, data) | |
320 | ), | |
321 | ||
322 | TP_fast_assign( | |
323 | __entry->id = id; | |
324 | __entry->address = address; | |
325 | __entry->data = data; | |
326 | ), | |
327 | ||
328 | TP_printk("vgpu%d:inject msi address %x data %x\n", | |
329 | __entry->id, __entry->address, __entry->data) | |
330 | ); | |
331 | ||
332 | TRACE_EVENT(render_mmio, | |
dc5718f4 | 333 | TP_PROTO(int old_id, int new_id, char *action, unsigned int reg, |
7fb6a7d6 XZ |
334 | unsigned int old_val, unsigned int new_val), |
335 | ||
3cc7644e | 336 | TP_ARGS(old_id, new_id, action, reg, old_val, new_val), |
7fb6a7d6 XZ |
337 | |
338 | TP_STRUCT__entry( | |
dc5718f4 WL |
339 | __field(int, old_id) |
340 | __field(int, new_id) | |
7fb6a7d6 XZ |
341 | __array(char, buf, GVT_TEMP_STR_LEN) |
342 | __field(unsigned int, reg) | |
343 | __field(unsigned int, old_val) | |
344 | __field(unsigned int, new_val) | |
345 | ), | |
346 | ||
347 | TP_fast_assign( | |
dc5718f4 WL |
348 | __entry->old_id = old_id; |
349 | __entry->new_id = new_id; | |
7fb6a7d6 XZ |
350 | snprintf(__entry->buf, GVT_TEMP_STR_LEN, "%s", action); |
351 | __entry->reg = reg; | |
352 | __entry->old_val = old_val; | |
353 | __entry->new_val = new_val; | |
354 | ), | |
355 | ||
dc5718f4 WL |
356 | TP_printk("VM%u -> VM%u %s reg %x, old %08x new %08x\n", |
357 | __entry->old_id, __entry->new_id, | |
358 | __entry->buf, __entry->reg, | |
7fb6a7d6 XZ |
359 | __entry->old_val, __entry->new_val) |
360 | ); | |
361 | ||
3f728236 ZW |
362 | #endif /* _GVT_TRACE_H_ */ |
363 | ||
364 | /* This part must be out of protection */ | |
365 | #undef TRACE_INCLUDE_PATH | |
366 | #define TRACE_INCLUDE_PATH . | |
367 | #undef TRACE_INCLUDE_FILE | |
368 | #define TRACE_INCLUDE_FILE trace | |
369 | #include <trace/define_trace.h> |