diff options
Diffstat (limited to 'driver/gator_marshaling.c')
-rw-r--r-- | driver/gator_marshaling.c | 119 |
1 files changed, 74 insertions, 45 deletions
diff --git a/driver/gator_marshaling.c b/driver/gator_marshaling.c index b2efdd2..627b441 100644 --- a/driver/gator_marshaling.c +++ b/driver/gator_marshaling.c | |||
@@ -1,5 +1,5 @@ | |||
1 | /** | 1 | /** |
2 | * Copyright (C) ARM Limited 2012. All rights reserved. | 2 | * Copyright (C) ARM Limited 2012-2013. All rights reserved. |
3 | * | 3 | * |
4 | * This program is free software; you can redistribute it and/or modify | 4 | * This program is free software; you can redistribute it and/or modify |
5 | * it under the terms of the GNU General Public License version 2 as | 5 | * it under the terms of the GNU General Public License version 2 as |
@@ -7,50 +7,72 @@ | |||
7 | * | 7 | * |
8 | */ | 8 | */ |
9 | 9 | ||
10 | static void marshal_summary(long long timestamp, long long uptime) | 10 | #define NEWLINE_CANARY \ |
11 | /* Unix */ \ | ||
12 | "1\n" \ | ||
13 | /* Windows */ \ | ||
14 | "2\r\n" \ | ||
15 | /* Mac OS */ \ | ||
16 | "3\r" \ | ||
17 | /* RISC OS */ \ | ||
18 | "4\n\r" \ | ||
19 | /* Add another character so the length isn't 0x0a bytes */ \ | ||
20 | "5" | ||
21 | |||
22 | static void marshal_summary(long long timestamp, long long uptime, const char * uname) | ||
11 | { | 23 | { |
24 | unsigned long flags; | ||
12 | int cpu = 0; | 25 | int cpu = 0; |
26 | |||
27 | local_irq_save(flags); | ||
28 | gator_buffer_write_string(cpu, SUMMARY_BUF, NEWLINE_CANARY); | ||
13 | gator_buffer_write_packed_int64(cpu, SUMMARY_BUF, timestamp); | 29 | gator_buffer_write_packed_int64(cpu, SUMMARY_BUF, timestamp); |
14 | gator_buffer_write_packed_int64(cpu, SUMMARY_BUF, uptime); | 30 | gator_buffer_write_packed_int64(cpu, SUMMARY_BUF, uptime); |
15 | buffer_check(cpu, SUMMARY_BUF); | 31 | gator_buffer_write_string(cpu, SUMMARY_BUF, uname); |
32 | // Commit the buffer now so it can be one of the first frames read by Streamline | ||
33 | gator_commit_buffer(cpu, SUMMARY_BUF, gator_get_time()); | ||
34 | local_irq_restore(flags); | ||
16 | } | 35 | } |
17 | 36 | ||
18 | static bool marshal_cookie_header(const char *text) | 37 | static bool marshal_cookie_header(const char *text) |
19 | { | 38 | { |
20 | int cpu = smp_processor_id(); | 39 | int cpu = get_physical_cpu(); |
21 | return buffer_check_space(cpu, NAME_BUF, strlen(text) + 3 * MAXSIZE_PACK32); | 40 | return buffer_check_space(cpu, NAME_BUF, strlen(text) + 3 * MAXSIZE_PACK32); |
22 | } | 41 | } |
23 | 42 | ||
24 | static void marshal_cookie(int cookie, const char *text) | 43 | static void marshal_cookie(int cookie, const char *text) |
25 | { | 44 | { |
26 | int cpu = smp_processor_id(); | 45 | int cpu = get_physical_cpu(); |
27 | // buffer_check_space already called by marshal_cookie_header | 46 | // buffer_check_space already called by marshal_cookie_header |
28 | gator_buffer_write_packed_int(cpu, NAME_BUF, MESSAGE_COOKIE); | 47 | gator_buffer_write_packed_int(cpu, NAME_BUF, MESSAGE_COOKIE); |
29 | gator_buffer_write_packed_int(cpu, NAME_BUF, cookie); | 48 | gator_buffer_write_packed_int(cpu, NAME_BUF, cookie); |
30 | gator_buffer_write_string(cpu, NAME_BUF, text); | 49 | gator_buffer_write_string(cpu, NAME_BUF, text); |
31 | buffer_check(cpu, NAME_BUF); | 50 | buffer_check(cpu, NAME_BUF, gator_get_time()); |
32 | } | 51 | } |
33 | 52 | ||
34 | static void marshal_thread_name(int pid, char *name) | 53 | static void marshal_thread_name(int pid, char *name) |
35 | { | 54 | { |
36 | unsigned long flags, cpu; | 55 | unsigned long flags, cpu; |
56 | u64 time; | ||
37 | local_irq_save(flags); | 57 | local_irq_save(flags); |
38 | cpu = smp_processor_id(); | 58 | cpu = get_physical_cpu(); |
59 | time = gator_get_time(); | ||
39 | if (buffer_check_space(cpu, NAME_BUF, TASK_COMM_LEN + 3 * MAXSIZE_PACK32 + MAXSIZE_PACK64)) { | 60 | if (buffer_check_space(cpu, NAME_BUF, TASK_COMM_LEN + 3 * MAXSIZE_PACK32 + MAXSIZE_PACK64)) { |
40 | gator_buffer_write_packed_int(cpu, NAME_BUF, MESSAGE_THREAD_NAME); | 61 | gator_buffer_write_packed_int(cpu, NAME_BUF, MESSAGE_THREAD_NAME); |
41 | gator_buffer_write_packed_int64(cpu, NAME_BUF, gator_get_time()); | 62 | gator_buffer_write_packed_int64(cpu, NAME_BUF, time); |
42 | gator_buffer_write_packed_int(cpu, NAME_BUF, pid); | 63 | gator_buffer_write_packed_int(cpu, NAME_BUF, pid); |
43 | gator_buffer_write_string(cpu, NAME_BUF, name); | 64 | gator_buffer_write_string(cpu, NAME_BUF, name); |
44 | } | 65 | } |
45 | buffer_check(cpu, NAME_BUF); | 66 | buffer_check(cpu, NAME_BUF, time); |
46 | local_irq_restore(flags); | 67 | local_irq_restore(flags); |
47 | } | 68 | } |
48 | 69 | ||
49 | static bool marshal_backtrace_header(int exec_cookie, int tgid, int pid, int inKernel) | 70 | static bool marshal_backtrace_header(int exec_cookie, int tgid, int pid, int inKernel) |
50 | { | 71 | { |
51 | int cpu = smp_processor_id(); | 72 | int cpu = get_physical_cpu(); |
73 | u64 time = gator_get_time(); | ||
52 | if (buffer_check_space(cpu, BACKTRACE_BUF, MAXSIZE_PACK64 + 5 * MAXSIZE_PACK32 + gator_backtrace_depth * 2 * MAXSIZE_PACK32)) { | 74 | if (buffer_check_space(cpu, BACKTRACE_BUF, MAXSIZE_PACK64 + 5 * MAXSIZE_PACK32 + gator_backtrace_depth * 2 * MAXSIZE_PACK32)) { |
53 | gator_buffer_write_packed_int64(cpu, BACKTRACE_BUF, gator_get_time()); | 75 | gator_buffer_write_packed_int64(cpu, BACKTRACE_BUF, time); |
54 | gator_buffer_write_packed_int(cpu, BACKTRACE_BUF, exec_cookie); | 76 | gator_buffer_write_packed_int(cpu, BACKTRACE_BUF, exec_cookie); |
55 | gator_buffer_write_packed_int(cpu, BACKTRACE_BUF, tgid); | 77 | gator_buffer_write_packed_int(cpu, BACKTRACE_BUF, tgid); |
56 | gator_buffer_write_packed_int(cpu, BACKTRACE_BUF, pid); | 78 | gator_buffer_write_packed_int(cpu, BACKTRACE_BUF, pid); |
@@ -59,30 +81,30 @@ static bool marshal_backtrace_header(int exec_cookie, int tgid, int pid, int inK | |||
59 | } | 81 | } |
60 | 82 | ||
61 | // Check and commit; commit is set to occur once buffer is 3/4 full | 83 | // Check and commit; commit is set to occur once buffer is 3/4 full |
62 | buffer_check(cpu, BACKTRACE_BUF); | 84 | buffer_check(cpu, BACKTRACE_BUF, time); |
63 | 85 | ||
64 | return false; | 86 | return false; |
65 | } | 87 | } |
66 | 88 | ||
67 | static void marshal_backtrace(unsigned long address, int cookie) | 89 | static void marshal_backtrace(unsigned long address, int cookie) |
68 | { | 90 | { |
69 | int cpu = smp_processor_id(); | 91 | int cpu = get_physical_cpu(); |
70 | gator_buffer_write_packed_int(cpu, BACKTRACE_BUF, cookie); | 92 | gator_buffer_write_packed_int(cpu, BACKTRACE_BUF, cookie); |
71 | gator_buffer_write_packed_int64(cpu, BACKTRACE_BUF, address); | 93 | gator_buffer_write_packed_int64(cpu, BACKTRACE_BUF, address); |
72 | } | 94 | } |
73 | 95 | ||
74 | static void marshal_backtrace_footer(void) | 96 | static void marshal_backtrace_footer(void) |
75 | { | 97 | { |
76 | int cpu = smp_processor_id(); | 98 | int cpu = get_physical_cpu(); |
77 | gator_buffer_write_packed_int(cpu, BACKTRACE_BUF, MESSAGE_END_BACKTRACE); | 99 | gator_buffer_write_packed_int(cpu, BACKTRACE_BUF, MESSAGE_END_BACKTRACE); |
78 | 100 | ||
79 | // Check and commit; commit is set to occur once buffer is 3/4 full | 101 | // Check and commit; commit is set to occur once buffer is 3/4 full |
80 | buffer_check(cpu, BACKTRACE_BUF); | 102 | buffer_check(cpu, BACKTRACE_BUF, gator_get_time()); |
81 | } | 103 | } |
82 | 104 | ||
83 | static bool marshal_event_header(void) | 105 | static bool marshal_event_header(void) |
84 | { | 106 | { |
85 | unsigned long flags, cpu = smp_processor_id(); | 107 | unsigned long flags, cpu = get_physical_cpu(); |
86 | bool retval = false; | 108 | bool retval = false; |
87 | 109 | ||
88 | local_irq_save(flags); | 110 | local_irq_save(flags); |
@@ -91,8 +113,6 @@ static bool marshal_event_header(void) | |||
91 | gator_buffer_write_packed_int64(cpu, BLOCK_COUNTER_BUF, gator_get_time()); | 113 | gator_buffer_write_packed_int64(cpu, BLOCK_COUNTER_BUF, gator_get_time()); |
92 | retval = true; | 114 | retval = true; |
93 | } | 115 | } |
94 | // Check and commit; commit is set to occur once buffer is 3/4 full | ||
95 | buffer_check(cpu, BLOCK_COUNTER_BUF); | ||
96 | local_irq_restore(flags); | 116 | local_irq_restore(flags); |
97 | 117 | ||
98 | return retval; | 118 | return retval; |
@@ -100,7 +120,7 @@ static bool marshal_event_header(void) | |||
100 | 120 | ||
101 | static void marshal_event(int len, int *buffer) | 121 | static void marshal_event(int len, int *buffer) |
102 | { | 122 | { |
103 | unsigned long i, flags, cpu = smp_processor_id(); | 123 | unsigned long i, flags, cpu = get_physical_cpu(); |
104 | 124 | ||
105 | if (len <= 0) | 125 | if (len <= 0) |
106 | return; | 126 | return; |
@@ -120,14 +140,12 @@ static void marshal_event(int len, int *buffer) | |||
120 | gator_buffer_write_packed_int(cpu, BLOCK_COUNTER_BUF, buffer[i]); | 140 | gator_buffer_write_packed_int(cpu, BLOCK_COUNTER_BUF, buffer[i]); |
121 | gator_buffer_write_packed_int(cpu, BLOCK_COUNTER_BUF, buffer[i + 1]); | 141 | gator_buffer_write_packed_int(cpu, BLOCK_COUNTER_BUF, buffer[i + 1]); |
122 | } | 142 | } |
123 | // Check and commit; commit is set to occur once buffer is 3/4 full | ||
124 | buffer_check(cpu, BLOCK_COUNTER_BUF); | ||
125 | local_irq_restore(flags); | 143 | local_irq_restore(flags); |
126 | } | 144 | } |
127 | 145 | ||
128 | static void marshal_event64(int len, long long *buffer64) | 146 | static void marshal_event64(int len, long long *buffer64) |
129 | { | 147 | { |
130 | unsigned long i, flags, cpu = smp_processor_id(); | 148 | unsigned long i, flags, cpu = get_physical_cpu(); |
131 | 149 | ||
132 | if (len <= 0) | 150 | if (len <= 0) |
133 | return; | 151 | return; |
@@ -147,8 +165,6 @@ static void marshal_event64(int len, long long *buffer64) | |||
147 | gator_buffer_write_packed_int64(cpu, BLOCK_COUNTER_BUF, buffer64[i]); | 165 | gator_buffer_write_packed_int64(cpu, BLOCK_COUNTER_BUF, buffer64[i]); |
148 | gator_buffer_write_packed_int64(cpu, BLOCK_COUNTER_BUF, buffer64[i + 1]); | 166 | gator_buffer_write_packed_int64(cpu, BLOCK_COUNTER_BUF, buffer64[i + 1]); |
149 | } | 167 | } |
150 | // Check and commit; commit is set to occur once buffer is 3/4 full | ||
151 | buffer_check(cpu, BLOCK_COUNTER_BUF); | ||
152 | local_irq_restore(flags); | 168 | local_irq_restore(flags); |
153 | } | 169 | } |
154 | 170 | ||
@@ -156,97 +172,107 @@ static void marshal_event64(int len, long long *buffer64) | |||
156 | static void marshal_event_single(int core, int key, int value) | 172 | static void marshal_event_single(int core, int key, int value) |
157 | { | 173 | { |
158 | unsigned long flags, cpu; | 174 | unsigned long flags, cpu; |
175 | u64 time; | ||
159 | 176 | ||
160 | local_irq_save(flags); | 177 | local_irq_save(flags); |
161 | cpu = smp_processor_id(); | 178 | cpu = get_physical_cpu(); |
179 | time = gator_get_time(); | ||
162 | if (buffer_check_space(cpu, COUNTER_BUF, MAXSIZE_PACK64 + 3 * MAXSIZE_PACK32)) { | 180 | if (buffer_check_space(cpu, COUNTER_BUF, MAXSIZE_PACK64 + 3 * MAXSIZE_PACK32)) { |
163 | gator_buffer_write_packed_int64(cpu, COUNTER_BUF, gator_get_time()); | 181 | gator_buffer_write_packed_int64(cpu, COUNTER_BUF, time); |
164 | gator_buffer_write_packed_int(cpu, COUNTER_BUF, core); | 182 | gator_buffer_write_packed_int(cpu, COUNTER_BUF, core); |
165 | gator_buffer_write_packed_int(cpu, COUNTER_BUF, key); | 183 | gator_buffer_write_packed_int(cpu, COUNTER_BUF, key); |
166 | gator_buffer_write_packed_int(cpu, COUNTER_BUF, value); | 184 | gator_buffer_write_packed_int(cpu, COUNTER_BUF, value); |
167 | } | 185 | } |
168 | // Check and commit; commit is set to occur once buffer is 3/4 full | 186 | // Check and commit; commit is set to occur once buffer is 3/4 full |
169 | buffer_check(cpu, COUNTER_BUF); | 187 | buffer_check(cpu, COUNTER_BUF, time); |
170 | local_irq_restore(flags); | 188 | local_irq_restore(flags); |
171 | } | 189 | } |
172 | #endif | 190 | #endif |
173 | 191 | ||
174 | static void marshal_sched_gpu_start(int unit, int core, int tgid, int pid) | 192 | static void marshal_sched_gpu_start(int unit, int core, int tgid, int pid) |
175 | { | 193 | { |
176 | unsigned long cpu = smp_processor_id(), flags; | 194 | unsigned long cpu = get_physical_cpu(), flags; |
195 | u64 time; | ||
177 | 196 | ||
178 | if (!per_cpu(gator_buffer, cpu)[GPU_TRACE_BUF]) | 197 | if (!per_cpu(gator_buffer, cpu)[GPU_TRACE_BUF]) |
179 | return; | 198 | return; |
180 | 199 | ||
181 | local_irq_save(flags); | 200 | local_irq_save(flags); |
201 | time = gator_get_time(); | ||
182 | if (buffer_check_space(cpu, GPU_TRACE_BUF, MAXSIZE_PACK64 + 5 * MAXSIZE_PACK32)) { | 202 | if (buffer_check_space(cpu, GPU_TRACE_BUF, MAXSIZE_PACK64 + 5 * MAXSIZE_PACK32)) { |
183 | gator_buffer_write_packed_int(cpu, GPU_TRACE_BUF, MESSAGE_GPU_START); | 203 | gator_buffer_write_packed_int(cpu, GPU_TRACE_BUF, MESSAGE_GPU_START); |
184 | gator_buffer_write_packed_int64(cpu, GPU_TRACE_BUF, gator_get_time()); | 204 | gator_buffer_write_packed_int64(cpu, GPU_TRACE_BUF, time); |
185 | gator_buffer_write_packed_int(cpu, GPU_TRACE_BUF, unit); | 205 | gator_buffer_write_packed_int(cpu, GPU_TRACE_BUF, unit); |
186 | gator_buffer_write_packed_int(cpu, GPU_TRACE_BUF, core); | 206 | gator_buffer_write_packed_int(cpu, GPU_TRACE_BUF, core); |
187 | gator_buffer_write_packed_int(cpu, GPU_TRACE_BUF, tgid); | 207 | gator_buffer_write_packed_int(cpu, GPU_TRACE_BUF, tgid); |
188 | gator_buffer_write_packed_int(cpu, GPU_TRACE_BUF, pid); | 208 | gator_buffer_write_packed_int(cpu, GPU_TRACE_BUF, pid); |
189 | } | 209 | } |
190 | // Check and commit; commit is set to occur once buffer is 3/4 full | 210 | // Check and commit; commit is set to occur once buffer is 3/4 full |
191 | buffer_check(cpu, GPU_TRACE_BUF); | 211 | buffer_check(cpu, GPU_TRACE_BUF, time); |
192 | local_irq_restore(flags); | 212 | local_irq_restore(flags); |
193 | } | 213 | } |
194 | 214 | ||
195 | static void marshal_sched_gpu_stop(int unit, int core) | 215 | static void marshal_sched_gpu_stop(int unit, int core) |
196 | { | 216 | { |
197 | unsigned long cpu = smp_processor_id(), flags; | 217 | unsigned long cpu = get_physical_cpu(), flags; |
218 | u64 time; | ||
198 | 219 | ||
199 | if (!per_cpu(gator_buffer, cpu)[GPU_TRACE_BUF]) | 220 | if (!per_cpu(gator_buffer, cpu)[GPU_TRACE_BUF]) |
200 | return; | 221 | return; |
201 | 222 | ||
202 | local_irq_save(flags); | 223 | local_irq_save(flags); |
224 | time = gator_get_time(); | ||
203 | if (buffer_check_space(cpu, GPU_TRACE_BUF, MAXSIZE_PACK64 + 3 * MAXSIZE_PACK32)) { | 225 | if (buffer_check_space(cpu, GPU_TRACE_BUF, MAXSIZE_PACK64 + 3 * MAXSIZE_PACK32)) { |
204 | gator_buffer_write_packed_int(cpu, GPU_TRACE_BUF, MESSAGE_GPU_STOP); | 226 | gator_buffer_write_packed_int(cpu, GPU_TRACE_BUF, MESSAGE_GPU_STOP); |
205 | gator_buffer_write_packed_int64(cpu, GPU_TRACE_BUF, gator_get_time()); | 227 | gator_buffer_write_packed_int64(cpu, GPU_TRACE_BUF, time); |
206 | gator_buffer_write_packed_int(cpu, GPU_TRACE_BUF, unit); | 228 | gator_buffer_write_packed_int(cpu, GPU_TRACE_BUF, unit); |
207 | gator_buffer_write_packed_int(cpu, GPU_TRACE_BUF, core); | 229 | gator_buffer_write_packed_int(cpu, GPU_TRACE_BUF, core); |
208 | } | 230 | } |
209 | // Check and commit; commit is set to occur once buffer is 3/4 full | 231 | // Check and commit; commit is set to occur once buffer is 3/4 full |
210 | buffer_check(cpu, GPU_TRACE_BUF); | 232 | buffer_check(cpu, GPU_TRACE_BUF, time); |
211 | local_irq_restore(flags); | 233 | local_irq_restore(flags); |
212 | } | 234 | } |
213 | 235 | ||
214 | static void marshal_sched_trace_switch(int tgid, int pid, int cookie, int state) | 236 | static void marshal_sched_trace_switch(int tgid, int pid, int cookie, int state) |
215 | { | 237 | { |
216 | unsigned long cpu = smp_processor_id(), flags; | 238 | unsigned long cpu = get_physical_cpu(), flags; |
239 | u64 time; | ||
217 | 240 | ||
218 | if (!per_cpu(gator_buffer, cpu)[SCHED_TRACE_BUF]) | 241 | if (!per_cpu(gator_buffer, cpu)[SCHED_TRACE_BUF]) |
219 | return; | 242 | return; |
220 | 243 | ||
221 | local_irq_save(flags); | 244 | local_irq_save(flags); |
245 | time = gator_get_time(); | ||
222 | if (buffer_check_space(cpu, SCHED_TRACE_BUF, MAXSIZE_PACK64 + 5 * MAXSIZE_PACK32)) { | 246 | if (buffer_check_space(cpu, SCHED_TRACE_BUF, MAXSIZE_PACK64 + 5 * MAXSIZE_PACK32)) { |
223 | gator_buffer_write_packed_int(cpu, SCHED_TRACE_BUF, MESSAGE_SCHED_SWITCH); | 247 | gator_buffer_write_packed_int(cpu, SCHED_TRACE_BUF, MESSAGE_SCHED_SWITCH); |
224 | gator_buffer_write_packed_int64(cpu, SCHED_TRACE_BUF, gator_get_time()); | 248 | gator_buffer_write_packed_int64(cpu, SCHED_TRACE_BUF, time); |
225 | gator_buffer_write_packed_int(cpu, SCHED_TRACE_BUF, tgid); | 249 | gator_buffer_write_packed_int(cpu, SCHED_TRACE_BUF, tgid); |
226 | gator_buffer_write_packed_int(cpu, SCHED_TRACE_BUF, pid); | 250 | gator_buffer_write_packed_int(cpu, SCHED_TRACE_BUF, pid); |
227 | gator_buffer_write_packed_int(cpu, SCHED_TRACE_BUF, cookie); | 251 | gator_buffer_write_packed_int(cpu, SCHED_TRACE_BUF, cookie); |
228 | gator_buffer_write_packed_int(cpu, SCHED_TRACE_BUF, state); | 252 | gator_buffer_write_packed_int(cpu, SCHED_TRACE_BUF, state); |
229 | } | 253 | } |
230 | // Check and commit; commit is set to occur once buffer is 3/4 full | 254 | // Check and commit; commit is set to occur once buffer is 3/4 full |
231 | buffer_check(cpu, SCHED_TRACE_BUF); | 255 | buffer_check(cpu, SCHED_TRACE_BUF, time); |
232 | local_irq_restore(flags); | 256 | local_irq_restore(flags); |
233 | } | 257 | } |
234 | 258 | ||
235 | static void marshal_sched_trace_exit(int tgid, int pid) | 259 | static void marshal_sched_trace_exit(int tgid, int pid) |
236 | { | 260 | { |
237 | unsigned long cpu = smp_processor_id(), flags; | 261 | unsigned long cpu = get_physical_cpu(), flags; |
262 | u64 time; | ||
238 | 263 | ||
239 | if (!per_cpu(gator_buffer, cpu)[SCHED_TRACE_BUF]) | 264 | if (!per_cpu(gator_buffer, cpu)[SCHED_TRACE_BUF]) |
240 | return; | 265 | return; |
241 | 266 | ||
242 | local_irq_save(flags); | 267 | local_irq_save(flags); |
268 | time = gator_get_time(); | ||
243 | if (buffer_check_space(cpu, SCHED_TRACE_BUF, MAXSIZE_PACK64 + 2 * MAXSIZE_PACK32)) { | 269 | if (buffer_check_space(cpu, SCHED_TRACE_BUF, MAXSIZE_PACK64 + 2 * MAXSIZE_PACK32)) { |
244 | gator_buffer_write_packed_int(cpu, SCHED_TRACE_BUF, MESSAGE_SCHED_EXIT); | 270 | gator_buffer_write_packed_int(cpu, SCHED_TRACE_BUF, MESSAGE_SCHED_EXIT); |
245 | gator_buffer_write_packed_int64(cpu, SCHED_TRACE_BUF, gator_get_time()); | 271 | gator_buffer_write_packed_int64(cpu, SCHED_TRACE_BUF, time); |
246 | gator_buffer_write_packed_int(cpu, SCHED_TRACE_BUF, pid); | 272 | gator_buffer_write_packed_int(cpu, SCHED_TRACE_BUF, pid); |
247 | } | 273 | } |
248 | // Check and commit; commit is set to occur once buffer is 3/4 full | 274 | // Check and commit; commit is set to occur once buffer is 3/4 full |
249 | buffer_check(cpu, SCHED_TRACE_BUF); | 275 | buffer_check(cpu, SCHED_TRACE_BUF, time); |
250 | local_irq_restore(flags); | 276 | local_irq_restore(flags); |
251 | } | 277 | } |
252 | 278 | ||
@@ -254,16 +280,18 @@ static void marshal_sched_trace_exit(int tgid, int pid) | |||
254 | static void marshal_idle(int core, int state) | 280 | static void marshal_idle(int core, int state) |
255 | { | 281 | { |
256 | unsigned long flags, cpu; | 282 | unsigned long flags, cpu; |
283 | u64 time; | ||
257 | 284 | ||
258 | local_irq_save(flags); | 285 | local_irq_save(flags); |
259 | cpu = smp_processor_id(); | 286 | cpu = get_physical_cpu(); |
287 | time = gator_get_time(); | ||
260 | if (buffer_check_space(cpu, IDLE_BUF, MAXSIZE_PACK64 + 2 * MAXSIZE_PACK32)) { | 288 | if (buffer_check_space(cpu, IDLE_BUF, MAXSIZE_PACK64 + 2 * MAXSIZE_PACK32)) { |
261 | gator_buffer_write_packed_int(cpu, IDLE_BUF, state); | 289 | gator_buffer_write_packed_int(cpu, IDLE_BUF, state); |
262 | gator_buffer_write_packed_int64(cpu, IDLE_BUF, gator_get_time()); | 290 | gator_buffer_write_packed_int64(cpu, IDLE_BUF, time); |
263 | gator_buffer_write_packed_int(cpu, IDLE_BUF, core); | 291 | gator_buffer_write_packed_int(cpu, IDLE_BUF, core); |
264 | } | 292 | } |
265 | // Check and commit; commit is set to occur once buffer is 3/4 full | 293 | // Check and commit; commit is set to occur once buffer is 3/4 full |
266 | buffer_check(cpu, IDLE_BUF); | 294 | buffer_check(cpu, IDLE_BUF, time); |
267 | local_irq_restore(flags); | 295 | local_irq_restore(flags); |
268 | } | 296 | } |
269 | #endif | 297 | #endif |
@@ -323,16 +351,17 @@ static void marshal_frame(int cpu, int buftype) | |||
323 | } | 351 | } |
324 | 352 | ||
325 | #if defined(__arm__) || defined(__aarch64__) | 353 | #if defined(__arm__) || defined(__aarch64__) |
326 | static void marshal_core_name(const char *name) | 354 | static void marshal_core_name(const int cpuid, const char *name) |
327 | { | 355 | { |
328 | int cpu = smp_processor_id(); | 356 | int cpu = get_physical_cpu(); |
329 | unsigned long flags; | 357 | unsigned long flags; |
330 | local_irq_save(flags); | 358 | local_irq_save(flags); |
331 | if (buffer_check_space(cpu, NAME_BUF, MAXSIZE_PACK32 + MAXSIZE_CORE_NAME)) { | 359 | if (buffer_check_space(cpu, NAME_BUF, MAXSIZE_PACK32 + MAXSIZE_CORE_NAME)) { |
332 | gator_buffer_write_packed_int(cpu, NAME_BUF, HRTIMER_CORE_NAME); | 360 | gator_buffer_write_packed_int(cpu, NAME_BUF, HRTIMER_CORE_NAME); |
361 | gator_buffer_write_packed_int(cpu, NAME_BUF, cpuid); | ||
333 | gator_buffer_write_string(cpu, NAME_BUF, name); | 362 | gator_buffer_write_string(cpu, NAME_BUF, name); |
334 | } | 363 | } |
335 | buffer_check(cpu, NAME_BUF); | 364 | buffer_check(cpu, NAME_BUF, gator_get_time()); |
336 | local_irq_restore(flags); | 365 | local_irq_restore(flags); |
337 | } | 366 | } |
338 | #endif | 367 | #endif |