diff options
author | Linus Torvalds <torvalds@linux-foundation.org> | 2011-07-24 12:06:47 -0400 |
---|---|---|
committer | Linus Torvalds <torvalds@linux-foundation.org> | 2011-07-24 12:06:47 -0400 |
commit | c61264f98c1a974ee6f545f61a4ab33b141d6bda (patch) | |
tree | 490e82c3bbf1403098b582f589eec378be727d4c /include/trace | |
parent | a23a334bd547e9462d9ca4a74608519a1e928848 (diff) | |
parent | bd9ddc875b6659f9f74dcfd285c472bc58041abd (diff) |
Merge branch 'upstream/xen-tracing2' of git://git.kernel.org/pub/scm/linux/kernel/git/jeremy/xen
* 'upstream/xen-tracing2' of git://git.kernel.org/pub/scm/linux/kernel/git/jeremy/xen:
xen/trace: use class for multicall trace
xen/trace: convert mmu events to use DECLARE_EVENT_CLASS()/DEFINE_EVENT()
xen/multicall: move *idx fields to start of mc_buffer
xen/multicall: special-case singleton hypercalls
xen/multicalls: add unlikely around slowpath in __xen_mc_entry()
xen/multicalls: disable MC_DEBUG
xen/mmu: tune pgtable alloc/release
xen/mmu: use extend_args for more mmuext updates
xen/trace: add tlb flush tracepoints
xen/trace: add segment desc tracing
xen/trace: add xen_pgd_(un)pin tracepoints
xen/trace: add ptpage alloc/release tracepoints
xen/trace: add mmu tracepoints
xen/trace: add multicall tracing
xen/trace: set up tracepoint skeleton
xen/multicalls: remove debugfs stats
trace/xen: add skeleton for Xen trace events
Diffstat (limited to 'include/trace')
-rw-r--r-- | include/trace/events/xen.h | 504 |
1 files changed, 504 insertions, 0 deletions
diff --git a/include/trace/events/xen.h b/include/trace/events/xen.h new file mode 100644 index 000000000000..44d8decee09e --- /dev/null +++ b/include/trace/events/xen.h | |||
@@ -0,0 +1,504 @@ | |||
1 | #undef TRACE_SYSTEM | ||
2 | #define TRACE_SYSTEM xen | ||
3 | |||
4 | #if !defined(_TRACE_XEN_H) || defined(TRACE_HEADER_MULTI_READ) | ||
5 | #define _TRACE_XEN_H | ||
6 | |||
7 | #include <linux/tracepoint.h> | ||
8 | #include <asm/paravirt_types.h> | ||
9 | #include <asm/xen/trace_types.h> | ||
10 | |||
11 | /* Multicalls */ | ||
12 | DECLARE_EVENT_CLASS(xen_mc__batch, | ||
13 | TP_PROTO(enum paravirt_lazy_mode mode), | ||
14 | TP_ARGS(mode), | ||
15 | TP_STRUCT__entry( | ||
16 | __field(enum paravirt_lazy_mode, mode) | ||
17 | ), | ||
18 | TP_fast_assign(__entry->mode = mode), | ||
19 | TP_printk("start batch LAZY_%s", | ||
20 | (__entry->mode == PARAVIRT_LAZY_MMU) ? "MMU" : | ||
21 | (__entry->mode == PARAVIRT_LAZY_CPU) ? "CPU" : "NONE") | ||
22 | ); | ||
23 | #define DEFINE_XEN_MC_BATCH(name) \ | ||
24 | DEFINE_EVENT(xen_mc__batch, name, \ | ||
25 | TP_PROTO(enum paravirt_lazy_mode mode), \ | ||
26 | TP_ARGS(mode)) | ||
27 | |||
28 | DEFINE_XEN_MC_BATCH(xen_mc_batch); | ||
29 | DEFINE_XEN_MC_BATCH(xen_mc_issue); | ||
30 | |||
31 | TRACE_EVENT(xen_mc_entry, | ||
32 | TP_PROTO(struct multicall_entry *mc, unsigned nargs), | ||
33 | TP_ARGS(mc, nargs), | ||
34 | TP_STRUCT__entry( | ||
35 | __field(unsigned int, op) | ||
36 | __field(unsigned int, nargs) | ||
37 | __array(unsigned long, args, 6) | ||
38 | ), | ||
39 | TP_fast_assign(__entry->op = mc->op; | ||
40 | __entry->nargs = nargs; | ||
41 | memcpy(__entry->args, mc->args, sizeof(unsigned long) * nargs); | ||
42 | memset(__entry->args + nargs, 0, sizeof(unsigned long) * (6 - nargs)); | ||
43 | ), | ||
44 | TP_printk("op %u%s args [%lx, %lx, %lx, %lx, %lx, %lx]", | ||
45 | __entry->op, xen_hypercall_name(__entry->op), | ||
46 | __entry->args[0], __entry->args[1], __entry->args[2], | ||
47 | __entry->args[3], __entry->args[4], __entry->args[5]) | ||
48 | ); | ||
49 | |||
50 | TRACE_EVENT(xen_mc_entry_alloc, | ||
51 | TP_PROTO(size_t args), | ||
52 | TP_ARGS(args), | ||
53 | TP_STRUCT__entry( | ||
54 | __field(size_t, args) | ||
55 | ), | ||
56 | TP_fast_assign(__entry->args = args), | ||
57 | TP_printk("alloc entry %zu arg bytes", __entry->args) | ||
58 | ); | ||
59 | |||
60 | TRACE_EVENT(xen_mc_callback, | ||
61 | TP_PROTO(xen_mc_callback_fn_t fn, void *data), | ||
62 | TP_ARGS(fn, data), | ||
63 | TP_STRUCT__entry( | ||
64 | __field(xen_mc_callback_fn_t, fn) | ||
65 | __field(void *, data) | ||
66 | ), | ||
67 | TP_fast_assign( | ||
68 | __entry->fn = fn; | ||
69 | __entry->data = data; | ||
70 | ), | ||
71 | TP_printk("callback %pf, data %p", | ||
72 | __entry->fn, __entry->data) | ||
73 | ); | ||
74 | |||
75 | TRACE_EVENT(xen_mc_flush_reason, | ||
76 | TP_PROTO(enum xen_mc_flush_reason reason), | ||
77 | TP_ARGS(reason), | ||
78 | TP_STRUCT__entry( | ||
79 | __field(enum xen_mc_flush_reason, reason) | ||
80 | ), | ||
81 | TP_fast_assign(__entry->reason = reason), | ||
82 | TP_printk("flush reason %s", | ||
83 | (__entry->reason == XEN_MC_FL_NONE) ? "NONE" : | ||
84 | (__entry->reason == XEN_MC_FL_BATCH) ? "BATCH" : | ||
85 | (__entry->reason == XEN_MC_FL_ARGS) ? "ARGS" : | ||
86 | (__entry->reason == XEN_MC_FL_CALLBACK) ? "CALLBACK" : "??") | ||
87 | ); | ||
88 | |||
89 | TRACE_EVENT(xen_mc_flush, | ||
90 | TP_PROTO(unsigned mcidx, unsigned argidx, unsigned cbidx), | ||
91 | TP_ARGS(mcidx, argidx, cbidx), | ||
92 | TP_STRUCT__entry( | ||
93 | __field(unsigned, mcidx) | ||
94 | __field(unsigned, argidx) | ||
95 | __field(unsigned, cbidx) | ||
96 | ), | ||
97 | TP_fast_assign(__entry->mcidx = mcidx; | ||
98 | __entry->argidx = argidx; | ||
99 | __entry->cbidx = cbidx), | ||
100 | TP_printk("flushing %u hypercalls, %u arg bytes, %u callbacks", | ||
101 | __entry->mcidx, __entry->argidx, __entry->cbidx) | ||
102 | ); | ||
103 | |||
104 | TRACE_EVENT(xen_mc_extend_args, | ||
105 | TP_PROTO(unsigned long op, size_t args, enum xen_mc_extend_args res), | ||
106 | TP_ARGS(op, args, res), | ||
107 | TP_STRUCT__entry( | ||
108 | __field(unsigned int, op) | ||
109 | __field(size_t, args) | ||
110 | __field(enum xen_mc_extend_args, res) | ||
111 | ), | ||
112 | TP_fast_assign(__entry->op = op; | ||
113 | __entry->args = args; | ||
114 | __entry->res = res), | ||
115 | TP_printk("extending op %u%s by %zu bytes res %s", | ||
116 | __entry->op, xen_hypercall_name(__entry->op), | ||
117 | __entry->args, | ||
118 | __entry->res == XEN_MC_XE_OK ? "OK" : | ||
119 | __entry->res == XEN_MC_XE_BAD_OP ? "BAD_OP" : | ||
120 | __entry->res == XEN_MC_XE_NO_SPACE ? "NO_SPACE" : "???") | ||
121 | ); | ||
122 | |||
123 | /* mmu */ | ||
124 | DECLARE_EVENT_CLASS(xen_mmu__set_pte, | ||
125 | TP_PROTO(pte_t *ptep, pte_t pteval), | ||
126 | TP_ARGS(ptep, pteval), | ||
127 | TP_STRUCT__entry( | ||
128 | __field(pte_t *, ptep) | ||
129 | __field(pteval_t, pteval) | ||
130 | ), | ||
131 | TP_fast_assign(__entry->ptep = ptep; | ||
132 | __entry->pteval = pteval.pte), | ||
133 | TP_printk("ptep %p pteval %0*llx (raw %0*llx)", | ||
134 | __entry->ptep, | ||
135 | (int)sizeof(pteval_t) * 2, (unsigned long long)pte_val(native_make_pte(__entry->pteval)), | ||
136 | (int)sizeof(pteval_t) * 2, (unsigned long long)__entry->pteval) | ||
137 | ); | ||
138 | |||
139 | #define DEFINE_XEN_MMU_SET_PTE(name) \ | ||
140 | DEFINE_EVENT(xen_mmu__set_pte, name, \ | ||
141 | TP_PROTO(pte_t *ptep, pte_t pteval), \ | ||
142 | TP_ARGS(ptep, pteval)) | ||
143 | |||
144 | DEFINE_XEN_MMU_SET_PTE(xen_mmu_set_pte); | ||
145 | DEFINE_XEN_MMU_SET_PTE(xen_mmu_set_pte_atomic); | ||
146 | |||
147 | TRACE_EVENT(xen_mmu_set_domain_pte, | ||
148 | TP_PROTO(pte_t *ptep, pte_t pteval, unsigned domid), | ||
149 | TP_ARGS(ptep, pteval, domid), | ||
150 | TP_STRUCT__entry( | ||
151 | __field(pte_t *, ptep) | ||
152 | __field(pteval_t, pteval) | ||
153 | __field(unsigned, domid) | ||
154 | ), | ||
155 | TP_fast_assign(__entry->ptep = ptep; | ||
156 | __entry->pteval = pteval.pte; | ||
157 | __entry->domid = domid), | ||
158 | TP_printk("ptep %p pteval %0*llx (raw %0*llx) domid %u", | ||
159 | __entry->ptep, | ||
160 | (int)sizeof(pteval_t) * 2, (unsigned long long)pte_val(native_make_pte(__entry->pteval)), | ||
161 | (int)sizeof(pteval_t) * 2, (unsigned long long)__entry->pteval, | ||
162 | __entry->domid) | ||
163 | ); | ||
164 | |||
165 | TRACE_EVENT(xen_mmu_set_pte_at, | ||
166 | TP_PROTO(struct mm_struct *mm, unsigned long addr, | ||
167 | pte_t *ptep, pte_t pteval), | ||
168 | TP_ARGS(mm, addr, ptep, pteval), | ||
169 | TP_STRUCT__entry( | ||
170 | __field(struct mm_struct *, mm) | ||
171 | __field(unsigned long, addr) | ||
172 | __field(pte_t *, ptep) | ||
173 | __field(pteval_t, pteval) | ||
174 | ), | ||
175 | TP_fast_assign(__entry->mm = mm; | ||
176 | __entry->addr = addr; | ||
177 | __entry->ptep = ptep; | ||
178 | __entry->pteval = pteval.pte), | ||
179 | TP_printk("mm %p addr %lx ptep %p pteval %0*llx (raw %0*llx)", | ||
180 | __entry->mm, __entry->addr, __entry->ptep, | ||
181 | (int)sizeof(pteval_t) * 2, (unsigned long long)pte_val(native_make_pte(__entry->pteval)), | ||
182 | (int)sizeof(pteval_t) * 2, (unsigned long long)__entry->pteval) | ||
183 | ); | ||
184 | |||
185 | TRACE_EVENT(xen_mmu_pte_clear, | ||
186 | TP_PROTO(struct mm_struct *mm, unsigned long addr, pte_t *ptep), | ||
187 | TP_ARGS(mm, addr, ptep), | ||
188 | TP_STRUCT__entry( | ||
189 | __field(struct mm_struct *, mm) | ||
190 | __field(unsigned long, addr) | ||
191 | __field(pte_t *, ptep) | ||
192 | ), | ||
193 | TP_fast_assign(__entry->mm = mm; | ||
194 | __entry->addr = addr; | ||
195 | __entry->ptep = ptep), | ||
196 | TP_printk("mm %p addr %lx ptep %p", | ||
197 | __entry->mm, __entry->addr, __entry->ptep) | ||
198 | ); | ||
199 | |||
200 | TRACE_EVENT(xen_mmu_set_pmd, | ||
201 | TP_PROTO(pmd_t *pmdp, pmd_t pmdval), | ||
202 | TP_ARGS(pmdp, pmdval), | ||
203 | TP_STRUCT__entry( | ||
204 | __field(pmd_t *, pmdp) | ||
205 | __field(pmdval_t, pmdval) | ||
206 | ), | ||
207 | TP_fast_assign(__entry->pmdp = pmdp; | ||
208 | __entry->pmdval = pmdval.pmd), | ||
209 | TP_printk("pmdp %p pmdval %0*llx (raw %0*llx)", | ||
210 | __entry->pmdp, | ||
211 | (int)sizeof(pmdval_t) * 2, (unsigned long long)pmd_val(native_make_pmd(__entry->pmdval)), | ||
212 | (int)sizeof(pmdval_t) * 2, (unsigned long long)__entry->pmdval) | ||
213 | ); | ||
214 | |||
215 | TRACE_EVENT(xen_mmu_pmd_clear, | ||
216 | TP_PROTO(pmd_t *pmdp), | ||
217 | TP_ARGS(pmdp), | ||
218 | TP_STRUCT__entry( | ||
219 | __field(pmd_t *, pmdp) | ||
220 | ), | ||
221 | TP_fast_assign(__entry->pmdp = pmdp), | ||
222 | TP_printk("pmdp %p", __entry->pmdp) | ||
223 | ); | ||
224 | |||
225 | #if PAGETABLE_LEVELS >= 4 | ||
226 | |||
227 | TRACE_EVENT(xen_mmu_set_pud, | ||
228 | TP_PROTO(pud_t *pudp, pud_t pudval), | ||
229 | TP_ARGS(pudp, pudval), | ||
230 | TP_STRUCT__entry( | ||
231 | __field(pud_t *, pudp) | ||
232 | __field(pudval_t, pudval) | ||
233 | ), | ||
234 | TP_fast_assign(__entry->pudp = pudp; | ||
235 | __entry->pudval = native_pud_val(pudval)), | ||
236 | TP_printk("pudp %p pudval %0*llx (raw %0*llx)", | ||
237 | __entry->pudp, | ||
238 | (int)sizeof(pudval_t) * 2, (unsigned long long)pud_val(native_make_pud(__entry->pudval)), | ||
239 | (int)sizeof(pudval_t) * 2, (unsigned long long)__entry->pudval) | ||
240 | ); | ||
241 | |||
242 | TRACE_EVENT(xen_mmu_set_pgd, | ||
243 | TP_PROTO(pgd_t *pgdp, pgd_t *user_pgdp, pgd_t pgdval), | ||
244 | TP_ARGS(pgdp, user_pgdp, pgdval), | ||
245 | TP_STRUCT__entry( | ||
246 | __field(pgd_t *, pgdp) | ||
247 | __field(pgd_t *, user_pgdp) | ||
248 | __field(pgdval_t, pgdval) | ||
249 | ), | ||
250 | TP_fast_assign(__entry->pgdp = pgdp; | ||
251 | __entry->user_pgdp = user_pgdp; | ||
252 | __entry->pgdval = pgdval.pgd), | ||
253 | TP_printk("pgdp %p user_pgdp %p pgdval %0*llx (raw %0*llx)", | ||
254 | __entry->pgdp, __entry->user_pgdp, | ||
255 | (int)sizeof(pgdval_t) * 2, (unsigned long long)pgd_val(native_make_pgd(__entry->pgdval)), | ||
256 | (int)sizeof(pgdval_t) * 2, (unsigned long long)__entry->pgdval) | ||
257 | ); | ||
258 | |||
259 | TRACE_EVENT(xen_mmu_pud_clear, | ||
260 | TP_PROTO(pud_t *pudp), | ||
261 | TP_ARGS(pudp), | ||
262 | TP_STRUCT__entry( | ||
263 | __field(pud_t *, pudp) | ||
264 | ), | ||
265 | TP_fast_assign(__entry->pudp = pudp), | ||
266 | TP_printk("pudp %p", __entry->pudp) | ||
267 | ); | ||
268 | #else | ||
269 | |||
270 | TRACE_EVENT(xen_mmu_set_pud, | ||
271 | TP_PROTO(pud_t *pudp, pud_t pudval), | ||
272 | TP_ARGS(pudp, pudval), | ||
273 | TP_STRUCT__entry( | ||
274 | __field(pud_t *, pudp) | ||
275 | __field(pudval_t, pudval) | ||
276 | ), | ||
277 | TP_fast_assign(__entry->pudp = pudp; | ||
278 | __entry->pudval = native_pud_val(pudval)), | ||
279 | TP_printk("pudp %p pudval %0*llx (raw %0*llx)", | ||
280 | __entry->pudp, | ||
281 | (int)sizeof(pudval_t) * 2, (unsigned long long)pgd_val(native_make_pgd(__entry->pudval)), | ||
282 | (int)sizeof(pudval_t) * 2, (unsigned long long)__entry->pudval) | ||
283 | ); | ||
284 | |||
285 | #endif | ||
286 | |||
287 | TRACE_EVENT(xen_mmu_pgd_clear, | ||
288 | TP_PROTO(pgd_t *pgdp), | ||
289 | TP_ARGS(pgdp), | ||
290 | TP_STRUCT__entry( | ||
291 | __field(pgd_t *, pgdp) | ||
292 | ), | ||
293 | TP_fast_assign(__entry->pgdp = pgdp), | ||
294 | TP_printk("pgdp %p", __entry->pgdp) | ||
295 | ); | ||
296 | |||
297 | DECLARE_EVENT_CLASS(xen_mmu_ptep_modify_prot, | ||
298 | TP_PROTO(struct mm_struct *mm, unsigned long addr, | ||
299 | pte_t *ptep, pte_t pteval), | ||
300 | TP_ARGS(mm, addr, ptep, pteval), | ||
301 | TP_STRUCT__entry( | ||
302 | __field(struct mm_struct *, mm) | ||
303 | __field(unsigned long, addr) | ||
304 | __field(pte_t *, ptep) | ||
305 | __field(pteval_t, pteval) | ||
306 | ), | ||
307 | TP_fast_assign(__entry->mm = mm; | ||
308 | __entry->addr = addr; | ||
309 | __entry->ptep = ptep; | ||
310 | __entry->pteval = pteval.pte), | ||
311 | TP_printk("mm %p addr %lx ptep %p pteval %0*llx (raw %0*llx)", | ||
312 | __entry->mm, __entry->addr, __entry->ptep, | ||
313 | (int)sizeof(pteval_t) * 2, (unsigned long long)pte_val(native_make_pte(__entry->pteval)), | ||
314 | (int)sizeof(pteval_t) * 2, (unsigned long long)__entry->pteval) | ||
315 | ); | ||
316 | #define DEFINE_XEN_MMU_PTEP_MODIFY_PROT(name) \ | ||
317 | DEFINE_EVENT(xen_mmu_ptep_modify_prot, name, \ | ||
318 | TP_PROTO(struct mm_struct *mm, unsigned long addr, \ | ||
319 | pte_t *ptep, pte_t pteval), \ | ||
320 | TP_ARGS(mm, addr, ptep, pteval)) | ||
321 | |||
322 | DEFINE_XEN_MMU_PTEP_MODIFY_PROT(xen_mmu_ptep_modify_prot_start); | ||
323 | DEFINE_XEN_MMU_PTEP_MODIFY_PROT(xen_mmu_ptep_modify_prot_commit); | ||
324 | |||
325 | TRACE_EVENT(xen_mmu_alloc_ptpage, | ||
326 | TP_PROTO(struct mm_struct *mm, unsigned long pfn, unsigned level, bool pinned), | ||
327 | TP_ARGS(mm, pfn, level, pinned), | ||
328 | TP_STRUCT__entry( | ||
329 | __field(struct mm_struct *, mm) | ||
330 | __field(unsigned long, pfn) | ||
331 | __field(unsigned, level) | ||
332 | __field(bool, pinned) | ||
333 | ), | ||
334 | TP_fast_assign(__entry->mm = mm; | ||
335 | __entry->pfn = pfn; | ||
336 | __entry->level = level; | ||
337 | __entry->pinned = pinned), | ||
338 | TP_printk("mm %p pfn %lx level %d %spinned", | ||
339 | __entry->mm, __entry->pfn, __entry->level, | ||
340 | __entry->pinned ? "" : "un") | ||
341 | ); | ||
342 | |||
343 | TRACE_EVENT(xen_mmu_release_ptpage, | ||
344 | TP_PROTO(unsigned long pfn, unsigned level, bool pinned), | ||
345 | TP_ARGS(pfn, level, pinned), | ||
346 | TP_STRUCT__entry( | ||
347 | __field(unsigned long, pfn) | ||
348 | __field(unsigned, level) | ||
349 | __field(bool, pinned) | ||
350 | ), | ||
351 | TP_fast_assign(__entry->pfn = pfn; | ||
352 | __entry->level = level; | ||
353 | __entry->pinned = pinned), | ||
354 | TP_printk("pfn %lx level %d %spinned", | ||
355 | __entry->pfn, __entry->level, | ||
356 | __entry->pinned ? "" : "un") | ||
357 | ); | ||
358 | |||
359 | DECLARE_EVENT_CLASS(xen_mmu_pgd, | ||
360 | TP_PROTO(struct mm_struct *mm, pgd_t *pgd), | ||
361 | TP_ARGS(mm, pgd), | ||
362 | TP_STRUCT__entry( | ||
363 | __field(struct mm_struct *, mm) | ||
364 | __field(pgd_t *, pgd) | ||
365 | ), | ||
366 | TP_fast_assign(__entry->mm = mm; | ||
367 | __entry->pgd = pgd), | ||
368 | TP_printk("mm %p pgd %p", __entry->mm, __entry->pgd) | ||
369 | ); | ||
370 | #define DEFINE_XEN_MMU_PGD_EVENT(name) \ | ||
371 | DEFINE_EVENT(xen_mmu_pgd, name, \ | ||
372 | TP_PROTO(struct mm_struct *mm, pgd_t *pgd), \ | ||
373 | TP_ARGS(mm, pgd)) | ||
374 | |||
375 | DEFINE_XEN_MMU_PGD_EVENT(xen_mmu_pgd_pin); | ||
376 | DEFINE_XEN_MMU_PGD_EVENT(xen_mmu_pgd_unpin); | ||
377 | |||
378 | TRACE_EVENT(xen_mmu_flush_tlb, | ||
379 | TP_PROTO(int x), | ||
380 | TP_ARGS(x), | ||
381 | TP_STRUCT__entry(__array(char, x, 0)), | ||
382 | TP_fast_assign((void)x), | ||
383 | TP_printk("%s", "") | ||
384 | ); | ||
385 | |||
386 | TRACE_EVENT(xen_mmu_flush_tlb_single, | ||
387 | TP_PROTO(unsigned long addr), | ||
388 | TP_ARGS(addr), | ||
389 | TP_STRUCT__entry( | ||
390 | __field(unsigned long, addr) | ||
391 | ), | ||
392 | TP_fast_assign(__entry->addr = addr), | ||
393 | TP_printk("addr %lx", __entry->addr) | ||
394 | ); | ||
395 | |||
396 | TRACE_EVENT(xen_mmu_flush_tlb_others, | ||
397 | TP_PROTO(const struct cpumask *cpus, struct mm_struct *mm, | ||
398 | unsigned long addr), | ||
399 | TP_ARGS(cpus, mm, addr), | ||
400 | TP_STRUCT__entry( | ||
401 | __field(unsigned, ncpus) | ||
402 | __field(struct mm_struct *, mm) | ||
403 | __field(unsigned long, addr) | ||
404 | ), | ||
405 | TP_fast_assign(__entry->ncpus = cpumask_weight(cpus); | ||
406 | __entry->mm = mm; | ||
407 | __entry->addr = addr), | ||
408 | TP_printk("ncpus %d mm %p addr %lx", | ||
409 | __entry->ncpus, __entry->mm, __entry->addr) | ||
410 | ); | ||
411 | |||
412 | TRACE_EVENT(xen_mmu_write_cr3, | ||
413 | TP_PROTO(bool kernel, unsigned long cr3), | ||
414 | TP_ARGS(kernel, cr3), | ||
415 | TP_STRUCT__entry( | ||
416 | __field(bool, kernel) | ||
417 | __field(unsigned long, cr3) | ||
418 | ), | ||
419 | TP_fast_assign(__entry->kernel = kernel; | ||
420 | __entry->cr3 = cr3), | ||
421 | TP_printk("%s cr3 %lx", | ||
422 | __entry->kernel ? "kernel" : "user", __entry->cr3) | ||
423 | ); | ||
424 | |||
425 | |||
426 | /* CPU */ | ||
427 | TRACE_EVENT(xen_cpu_write_ldt_entry, | ||
428 | TP_PROTO(struct desc_struct *dt, int entrynum, u64 desc), | ||
429 | TP_ARGS(dt, entrynum, desc), | ||
430 | TP_STRUCT__entry( | ||
431 | __field(struct desc_struct *, dt) | ||
432 | __field(int, entrynum) | ||
433 | __field(u64, desc) | ||
434 | ), | ||
435 | TP_fast_assign(__entry->dt = dt; | ||
436 | __entry->entrynum = entrynum; | ||
437 | __entry->desc = desc; | ||
438 | ), | ||
439 | TP_printk("dt %p entrynum %d entry %016llx", | ||
440 | __entry->dt, __entry->entrynum, | ||
441 | (unsigned long long)__entry->desc) | ||
442 | ); | ||
443 | |||
444 | TRACE_EVENT(xen_cpu_write_idt_entry, | ||
445 | TP_PROTO(gate_desc *dt, int entrynum, const gate_desc *ent), | ||
446 | TP_ARGS(dt, entrynum, ent), | ||
447 | TP_STRUCT__entry( | ||
448 | __field(gate_desc *, dt) | ||
449 | __field(int, entrynum) | ||
450 | ), | ||
451 | TP_fast_assign(__entry->dt = dt; | ||
452 | __entry->entrynum = entrynum; | ||
453 | ), | ||
454 | TP_printk("dt %p entrynum %d", | ||
455 | __entry->dt, __entry->entrynum) | ||
456 | ); | ||
457 | |||
458 | TRACE_EVENT(xen_cpu_load_idt, | ||
459 | TP_PROTO(const struct desc_ptr *desc), | ||
460 | TP_ARGS(desc), | ||
461 | TP_STRUCT__entry( | ||
462 | __field(unsigned long, addr) | ||
463 | ), | ||
464 | TP_fast_assign(__entry->addr = desc->address), | ||
465 | TP_printk("addr %lx", __entry->addr) | ||
466 | ); | ||
467 | |||
468 | TRACE_EVENT(xen_cpu_write_gdt_entry, | ||
469 | TP_PROTO(struct desc_struct *dt, int entrynum, const void *desc, int type), | ||
470 | TP_ARGS(dt, entrynum, desc, type), | ||
471 | TP_STRUCT__entry( | ||
472 | __field(u64, desc) | ||
473 | __field(struct desc_struct *, dt) | ||
474 | __field(int, entrynum) | ||
475 | __field(int, type) | ||
476 | ), | ||
477 | TP_fast_assign(__entry->dt = dt; | ||
478 | __entry->entrynum = entrynum; | ||
479 | __entry->desc = *(u64 *)desc; | ||
480 | __entry->type = type; | ||
481 | ), | ||
482 | TP_printk("dt %p entrynum %d type %d desc %016llx", | ||
483 | __entry->dt, __entry->entrynum, __entry->type, | ||
484 | (unsigned long long)__entry->desc) | ||
485 | ); | ||
486 | |||
487 | TRACE_EVENT(xen_cpu_set_ldt, | ||
488 | TP_PROTO(const void *addr, unsigned entries), | ||
489 | TP_ARGS(addr, entries), | ||
490 | TP_STRUCT__entry( | ||
491 | __field(const void *, addr) | ||
492 | __field(unsigned, entries) | ||
493 | ), | ||
494 | TP_fast_assign(__entry->addr = addr; | ||
495 | __entry->entries = entries), | ||
496 | TP_printk("addr %p entries %u", | ||
497 | __entry->addr, __entry->entries) | ||
498 | ); | ||
499 | |||
500 | |||
501 | #endif /* _TRACE_XEN_H */ | ||
502 | |||
503 | /* This part must be outside protection */ | ||
504 | #include <trace/define_trace.h> | ||