1 /*
2 *
3 * (C) COPYRIGHT 2015-2017 ARM Limited. All rights reserved.
4 *
5 * This program is free software and is provided to you under the terms of the
6 * GNU General Public License version 2 as published by the Free Software
7 * Foundation, and any use by you of this program is subject to the terms
8 * of such GNU licence.
9 *
10 * A copy of the licence is included with the program, and can also be obtained
11 * from Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
12 * Boston, MA 02110-1301, USA.
13 *
14 */
15
16
17
18 #include <linux/anon_inodes.h>
19 #include <linux/atomic.h>
20 #include <linux/file.h>
21 #include <linux/mutex.h>
22 #include <linux/poll.h>
23 #include <linux/spinlock.h>
24 #include <linux/string.h>
25 #include <linux/stringify.h>
26 #include <linux/timer.h>
27 #include <linux/wait.h>
28
29 #include <mali_kbase.h>
30 #include <mali_kbase_jm.h>
31 #include <mali_kbase_tlstream.h>
32
33 /*****************************************************************************/
34
35 /* The version of swtrace protocol used in timeline stream. */
36 #define SWTRACE_VERSION 3
37
38 /* The maximum expected length of string in tracepoint descriptor. */
39 #define STRLEN_MAX 64 /* bytes */
40
41 /* The number of nanoseconds in a second. */
42 #define NSECS_IN_SEC 1000000000ull /* ns */
43
44 /* The period of autoflush checker execution in milliseconds. */
45 #define AUTOFLUSH_INTERVAL 1000 /* ms */
46
47 /* The maximum size of a single packet used by timeline. */
48 #define PACKET_SIZE 4096 /* bytes */
49
50 /* The number of packets used by one timeline stream. */
51 #define PACKET_COUNT 16
52
53 /* The number of bytes reserved for packet header.
54 * These value must be defined according to MIPE documentation. */
55 #define PACKET_HEADER_SIZE 8 /* bytes */
56
57 /* The number of bytes reserved for packet sequence number.
58 * These value must be defined according to MIPE documentation. */
59 #define PACKET_NUMBER_SIZE 4 /* bytes */
60
61 /* Packet header - first word.
62 * These values must be defined according to MIPE documentation. */
63 #define PACKET_STREAMID_POS 0
64 #define PACKET_STREAMID_LEN 8
65 #define PACKET_RSVD1_POS (PACKET_STREAMID_POS + PACKET_STREAMID_LEN)
66 #define PACKET_RSVD1_LEN 8
67 #define PACKET_TYPE_POS (PACKET_RSVD1_POS + PACKET_RSVD1_LEN)
68 #define PACKET_TYPE_LEN 3
69 #define PACKET_CLASS_POS (PACKET_TYPE_POS + PACKET_TYPE_LEN)
70 #define PACKET_CLASS_LEN 7
71 #define PACKET_FAMILY_POS (PACKET_CLASS_POS + PACKET_CLASS_LEN)
72 #define PACKET_FAMILY_LEN 6
73
74 /* Packet header - second word
75 * These values must be defined according to MIPE documentation. */
76 #define PACKET_LENGTH_POS 0
77 #define PACKET_LENGTH_LEN 24
78 #define PACKET_SEQBIT_POS (PACKET_LENGTH_POS + PACKET_LENGTH_LEN)
79 #define PACKET_SEQBIT_LEN 1
80 #define PACKET_RSVD2_POS (PACKET_SEQBIT_POS + PACKET_SEQBIT_LEN)
81 #define PACKET_RSVD2_LEN 7
82
83 /* Types of streams generated by timeline.
84 * Order is significant! Header streams must precede respective body streams. */
85 enum tl_stream_type {
86 TL_STREAM_TYPE_OBJ_HEADER,
87 TL_STREAM_TYPE_OBJ_SUMMARY,
88 TL_STREAM_TYPE_OBJ,
89 TL_STREAM_TYPE_AUX_HEADER,
90 TL_STREAM_TYPE_AUX,
91
92 TL_STREAM_TYPE_COUNT
93 };
94
95 /* Timeline packet family ids.
96 * Values are significant! Check MIPE documentation. */
97 enum tl_packet_family {
98 TL_PACKET_FAMILY_CTRL = 0, /* control packets */
99 TL_PACKET_FAMILY_TL = 1, /* timeline packets */
100
101 TL_PACKET_FAMILY_COUNT
102 };
103
104 /* Packet classes used in timeline streams.
105 * Values are significant! Check MIPE documentation. */
106 enum tl_packet_class {
107 TL_PACKET_CLASS_OBJ = 0, /* timeline objects packet */
108 TL_PACKET_CLASS_AUX = 1, /* auxiliary events packet */
109 };
110
111 /* Packet types used in timeline streams.
112 * Values are significant! Check MIPE documentation. */
113 enum tl_packet_type {
114 TL_PACKET_TYPE_HEADER = 0, /* stream's header/directory */
115 TL_PACKET_TYPE_BODY = 1, /* stream's body */
116 TL_PACKET_TYPE_SUMMARY = 2, /* stream's summary */
117 };
118
119 /* Message ids of trace events that are recorded in the timeline stream. */
120 enum tl_msg_id_obj {
121 /* Timeline object events. */
122 KBASE_TL_NEW_CTX,
123 KBASE_TL_NEW_GPU,
124 KBASE_TL_NEW_LPU,
125 KBASE_TL_NEW_ATOM,
126 KBASE_TL_NEW_AS,
127 KBASE_TL_DEL_CTX,
128 KBASE_TL_DEL_ATOM,
129 KBASE_TL_LIFELINK_LPU_GPU,
130 KBASE_TL_LIFELINK_AS_GPU,
131 KBASE_TL_RET_CTX_LPU,
132 KBASE_TL_RET_ATOM_CTX,
133 KBASE_TL_RET_ATOM_LPU,
134 KBASE_TL_NRET_CTX_LPU,
135 KBASE_TL_NRET_ATOM_CTX,
136 KBASE_TL_NRET_ATOM_LPU,
137 KBASE_TL_RET_AS_CTX,
138 KBASE_TL_NRET_AS_CTX,
139 KBASE_TL_RET_ATOM_AS,
140 KBASE_TL_NRET_ATOM_AS,
141 KBASE_TL_DEP_ATOM_ATOM,
142 KBASE_TL_NDEP_ATOM_ATOM,
143 KBASE_TL_RDEP_ATOM_ATOM,
144 KBASE_TL_ATTRIB_ATOM_CONFIG,
145 KBASE_TL_ATTRIB_ATOM_PRIORITY,
146 KBASE_TL_ATTRIB_ATOM_STATE,
147 KBASE_TL_ATTRIB_ATOM_PRIORITY_CHANGE,
148 KBASE_TL_ATTRIB_ATOM_JIT,
149 KBASE_TL_ATTRIB_AS_CONFIG,
150 KBASE_TL_EVENT_LPU_SOFTSTOP,
151 KBASE_TL_EVENT_ATOM_SOFTSTOP_EX,
152 KBASE_TL_EVENT_ATOM_SOFTSTOP_ISSUE,
153
154 /* Job dump specific events. */
155 KBASE_JD_GPU_SOFT_RESET
156 };
157
158 /* Message ids of trace events that are recorded in the auxiliary stream. */
159 enum tl_msg_id_aux {
160 KBASE_AUX_PM_STATE,
161 KBASE_AUX_PAGEFAULT,
162 KBASE_AUX_PAGESALLOC,
163 KBASE_AUX_DEVFREQ_TARGET,
164 KBASE_AUX_PROTECTED_ENTER_START,
165 KBASE_AUX_PROTECTED_ENTER_END,
166 KBASE_AUX_PROTECTED_LEAVE_START,
167 KBASE_AUX_PROTECTED_LEAVE_END
168 };
169
170 /*****************************************************************************/
171
172 /**
173 * struct tl_stream - timeline stream structure
174 * @lock: message order lock
175 * @buffer: array of buffers
176 * @wbi: write buffer index
177 * @rbi: read buffer index
178 * @numbered: if non-zero stream's packets are sequentially numbered
179 * @autoflush_counter: counter tracking stream's autoflush state
180 *
181 * This structure holds information needed to construct proper packets in the
182 * timeline stream. Each message in sequence must bear timestamp that is greater
183 * to one in previous message in the same stream. For this reason lock is held
184 * throughout the process of message creation. Each stream contains set of
185 * buffers. Each buffer will hold one MIPE packet. In case there is no free
186 * space required to store incoming message the oldest buffer is discarded.
187 * Each packet in timeline body stream has sequence number embedded (this value
188 * must increment monotonically and is used by packets receiver to discover
189 * buffer overflows.
190 * Autoflush counter is set to negative number when there is no data pending
191 * for flush and it is set to zero on every update of the buffer. Autoflush
192 * timer will increment the counter by one on every expiry. In case there will
193 * be no activity on the buffer during two consecutive timer expiries, stream
194 * buffer will be flushed.
195 */
196 struct tl_stream {
197 spinlock_t lock;
198
199 struct {
200 atomic_t size; /* number of bytes in buffer */
201 char data[PACKET_SIZE]; /* buffer's data */
202 } buffer[PACKET_COUNT];
203
204 atomic_t wbi;
205 atomic_t rbi;
206
207 int numbered;
208 atomic_t autoflush_counter;
209 };
210
211 /**
212 * struct tp_desc - tracepoint message descriptor structure
213 * @id: tracepoint ID identifying message in stream
214 * @id_str: human readable version of tracepoint ID
215 * @name: tracepoint description
216 * @arg_types: tracepoint's arguments types declaration
217 * @arg_names: comma separated list of tracepoint's arguments names
218 */
219 struct tp_desc {
220 u32 id;
221 const char *id_str;
222 const char *name;
223 const char *arg_types;
224 const char *arg_names;
225 };
226
227 /*****************************************************************************/
228
229 /* Configuration of timeline streams generated by kernel.
230 * Kernel emit only streams containing either timeline object events or
231 * auxiliary events. All streams have stream id value of 1 (as opposed to user
232 * space streams that have value of 0). */
233 static const struct {
234 enum tl_packet_family pkt_family;
235 enum tl_packet_class pkt_class;
236 enum tl_packet_type pkt_type;
237 unsigned int stream_id;
238 } tl_stream_cfg[TL_STREAM_TYPE_COUNT] = {
239 {TL_PACKET_FAMILY_TL, TL_PACKET_CLASS_OBJ, TL_PACKET_TYPE_HEADER, 1},
240 {TL_PACKET_FAMILY_TL, TL_PACKET_CLASS_OBJ, TL_PACKET_TYPE_SUMMARY, 1},
241 {TL_PACKET_FAMILY_TL, TL_PACKET_CLASS_OBJ, TL_PACKET_TYPE_BODY, 1},
242 {TL_PACKET_FAMILY_TL, TL_PACKET_CLASS_AUX, TL_PACKET_TYPE_HEADER, 1},
243 {TL_PACKET_FAMILY_TL, TL_PACKET_CLASS_AUX, TL_PACKET_TYPE_BODY, 1}
244 };
245
246 /* The timeline streams generated by kernel. */
247 static struct tl_stream *tl_stream[TL_STREAM_TYPE_COUNT];
248
249 /* Autoflush timer. */
250 static struct timer_list autoflush_timer;
251
252 /* If non-zero autoflush timer is active. */
253 static atomic_t autoflush_timer_active;
254
255 /* Reader lock. Only one reader is allowed to have access to the timeline
256 * streams at any given time. */
257 static DEFINE_MUTEX(tl_reader_lock);
258
259 /* Timeline stream event queue. */
260 static DECLARE_WAIT_QUEUE_HEAD(tl_event_queue);
261
262 /* The timeline stream file operations functions. */
263 static ssize_t kbasep_tlstream_read(
264 struct file *filp,
265 char __user *buffer,
266 size_t size,
267 loff_t *f_pos);
268 static unsigned int kbasep_tlstream_poll(struct file *filp, poll_table *wait);
269 static int kbasep_tlstream_release(struct inode *inode, struct file *filp);
270
271 /* The timeline stream file operations structure. */
272 static const struct file_operations kbasep_tlstream_fops = {
273 .release = kbasep_tlstream_release,
274 .read = kbasep_tlstream_read,
275 .poll = kbasep_tlstream_poll,
276 };
277
278 /* Descriptors of timeline messages transmitted in object events stream. */
279 static const struct tp_desc tp_desc_obj[] = {
280 {
281 KBASE_TL_NEW_CTX,
282 __stringify(KBASE_TL_NEW_CTX),
283 "object ctx is created",
284 "@pII",
285 "ctx,ctx_nr,tgid"
286 },
287 {
288 KBASE_TL_NEW_GPU,
289 __stringify(KBASE_TL_NEW_GPU),
290 "object gpu is created",
291 "@pII",
292 "gpu,gpu_id,core_count"
293 },
294 {
295 KBASE_TL_NEW_LPU,
296 __stringify(KBASE_TL_NEW_LPU),
297 "object lpu is created",
298 "@pII",
299 "lpu,lpu_nr,lpu_fn"
300 },
301 {
302 KBASE_TL_NEW_ATOM,
303 __stringify(KBASE_TL_NEW_ATOM),
304 "object atom is created",
305 "@pI",
306 "atom,atom_nr"
307 },
308 {
309 KBASE_TL_NEW_AS,
310 __stringify(KBASE_TL_NEW_AS),
311 "address space object is created",
312 "@pI",
313 "address_space,as_nr"
314 },
315 {
316 KBASE_TL_DEL_CTX,
317 __stringify(KBASE_TL_DEL_CTX),
318 "context is destroyed",
319 "@p",
320 "ctx"
321 },
322 {
323 KBASE_TL_DEL_ATOM,
324 __stringify(KBASE_TL_DEL_ATOM),
325 "atom is destroyed",
326 "@p",
327 "atom"
328 },
329 {
330 KBASE_TL_LIFELINK_LPU_GPU,
331 __stringify(KBASE_TL_LIFELINK_LPU_GPU),
332 "lpu is deleted with gpu",
333 "@pp",
334 "lpu,gpu"
335 },
336 {
337 KBASE_TL_LIFELINK_AS_GPU,
338 __stringify(KBASE_TL_LIFELINK_AS_GPU),
339 "address space is deleted with gpu",
340 "@pp",
341 "address_space,gpu"
342 },
343 {
344 KBASE_TL_RET_CTX_LPU,
345 __stringify(KBASE_TL_RET_CTX_LPU),
346 "context is retained by lpu",
347 "@pp",
348 "ctx,lpu"
349 },
350 {
351 KBASE_TL_RET_ATOM_CTX,
352 __stringify(KBASE_TL_RET_ATOM_CTX),
353 "atom is retained by context",
354 "@pp",
355 "atom,ctx"
356 },
357 {
358 KBASE_TL_RET_ATOM_LPU,
359 __stringify(KBASE_TL_RET_ATOM_LPU),
360 "atom is retained by lpu",
361 "@pps",
362 "atom,lpu,attrib_match_list"
363 },
364 {
365 KBASE_TL_NRET_CTX_LPU,
366 __stringify(KBASE_TL_NRET_CTX_LPU),
367 "context is released by lpu",
368 "@pp",
369 "ctx,lpu"
370 },
371 {
372 KBASE_TL_NRET_ATOM_CTX,
373 __stringify(KBASE_TL_NRET_ATOM_CTX),
374 "atom is released by context",
375 "@pp",
376 "atom,ctx"
377 },
378 {
379 KBASE_TL_NRET_ATOM_LPU,
380 __stringify(KBASE_TL_NRET_ATOM_LPU),
381 "atom is released by lpu",
382 "@pp",
383 "atom,lpu"
384 },
385 {
386 KBASE_TL_RET_AS_CTX,
387 __stringify(KBASE_TL_RET_AS_CTX),
388 "address space is retained by context",
389 "@pp",
390 "address_space,ctx"
391 },
392 {
393 KBASE_TL_NRET_AS_CTX,
394 __stringify(KBASE_TL_NRET_AS_CTX),
395 "address space is released by context",
396 "@pp",
397 "address_space,ctx"
398 },
399 {
400 KBASE_TL_RET_ATOM_AS,
401 __stringify(KBASE_TL_RET_ATOM_AS),
402 "atom is retained by address space",
403 "@pp",
404 "atom,address_space"
405 },
406 {
407 KBASE_TL_NRET_ATOM_AS,
408 __stringify(KBASE_TL_NRET_ATOM_AS),
409 "atom is released by address space",
410 "@pp",
411 "atom,address_space"
412 },
413 {
414 KBASE_TL_DEP_ATOM_ATOM,
415 __stringify(KBASE_TL_DEP_ATOM_ATOM),
416 "atom2 depends on atom1",
417 "@pp",
418 "atom1,atom2"
419 },
420 {
421 KBASE_TL_NDEP_ATOM_ATOM,
422 __stringify(KBASE_TL_NDEP_ATOM_ATOM),
423 "atom2 no longer depends on atom1",
424 "@pp",
425 "atom1,atom2"
426 },
427 {
428 KBASE_TL_RDEP_ATOM_ATOM,
429 __stringify(KBASE_TL_RDEP_ATOM_ATOM),
430 "resolved dependecy of atom2 depending on atom1",
431 "@pp",
432 "atom1,atom2"
433 },
434 {
435 KBASE_TL_ATTRIB_ATOM_CONFIG,
436 __stringify(KBASE_TL_ATTRIB_ATOM_CONFIG),
437 "atom job slot attributes",
438 "@pLLI",
439 "atom,descriptor,affinity,config"
440 },
441 {
442 KBASE_TL_ATTRIB_ATOM_PRIORITY,
443 __stringify(KBASE_TL_ATTRIB_ATOM_PRIORITY),
444 "atom priority",
445 "@pI",
446 "atom,prio"
447 },
448 {
449 KBASE_TL_ATTRIB_ATOM_STATE,
450 __stringify(KBASE_TL_ATTRIB_ATOM_STATE),
451 "atom state",
452 "@pI",
453 "atom,state"
454 },
455 {
456 KBASE_TL_ATTRIB_ATOM_PRIORITY_CHANGE,
457 __stringify(KBASE_TL_ATTRIB_ATOM_PRIORITY_CHANGE),
458 "atom caused priority change",
459 "@p",
460 "atom"
461 },
462 {
463 KBASE_TL_ATTRIB_ATOM_JIT,
464 __stringify(KBASE_TL_ATTRIB_ATOM_JIT),
465 "jit done for atom",
466 "@pLL",
467 "atom,edit_addr,new_addr"
468 },
469 {
470 KBASE_TL_ATTRIB_AS_CONFIG,
471 __stringify(KBASE_TL_ATTRIB_AS_CONFIG),
472 "address space attributes",
473 "@pLLL",
474 "address_space,transtab,memattr,transcfg"
475 },
476 {
477 KBASE_TL_EVENT_LPU_SOFTSTOP,
478 __stringify(KBASE_TL_EVENT_LPU_SOFTSTOP),
479 "softstop event on given lpu",
480 "@p",
481 "lpu"
482 },
483 {
484 KBASE_TL_EVENT_ATOM_SOFTSTOP_EX,
485 __stringify(KBASE_TL_EVENT_ATOM_SOFTSTOP_EX),
486 "atom softstopped",
487 "@p",
488 "atom"
489 },
490 {
491 KBASE_TL_EVENT_ATOM_SOFTSTOP_ISSUE,
492 __stringify(KBASE_TL_EVENT_SOFTSTOP_ISSUE),
493 "atom softstop issued",
494 "@p",
495 "atom"
496 },
497 {
498 KBASE_JD_GPU_SOFT_RESET,
499 __stringify(KBASE_JD_GPU_SOFT_RESET),
500 "gpu soft reset",
501 "@p",
502 "gpu"
503 },
504 };
505
506 /* Descriptors of timeline messages transmitted in auxiliary events stream. */
507 static const struct tp_desc tp_desc_aux[] = {
508 {
509 KBASE_AUX_PM_STATE,
510 __stringify(KBASE_AUX_PM_STATE),
511 "PM state",
512 "@IL",
513 "core_type,core_state_bitset"
514 },
515 {
516 KBASE_AUX_PAGEFAULT,
517 __stringify(KBASE_AUX_PAGEFAULT),
518 "Page fault",
519 "@IL",
520 "ctx_nr,page_cnt_change"
521 },
522 {
523 KBASE_AUX_PAGESALLOC,
524 __stringify(KBASE_AUX_PAGESALLOC),
525 "Total alloc pages change",
526 "@IL",
527 "ctx_nr,page_cnt"
528 },
529 {
530 KBASE_AUX_DEVFREQ_TARGET,
531 __stringify(KBASE_AUX_DEVFREQ_TARGET),
532 "New device frequency target",
533 "@L",
534 "target_freq"
535 },
536 {
537 KBASE_AUX_PROTECTED_ENTER_START,
538 __stringify(KBASE_AUX_PROTECTED_ENTER_START),
539 "enter protected mode start",
540 "@p",
541 "gpu"
542 },
543 {
544 KBASE_AUX_PROTECTED_ENTER_END,
545 __stringify(KBASE_AUX_PROTECTED_ENTER_END),
546 "enter protected mode end",
547 "@p",
548 "gpu"
549 },
550 {
551 KBASE_AUX_PROTECTED_LEAVE_START,
552 __stringify(KBASE_AUX_PROTECTED_LEAVE_START),
553 "leave protected mode start",
554 "@p",
555 "gpu"
556 },
557 {
558 KBASE_AUX_PROTECTED_LEAVE_END,
559 __stringify(KBASE_AUX_PROTECTED_LEAVE_END),
560 "leave protected mode end",
561 "@p",
562 "gpu"
563 }
564 };
565
566 #if MALI_UNIT_TEST
567 /* Number of bytes read by user. */
568 static atomic_t tlstream_bytes_collected = {0};
569
570 /* Number of bytes generated by tracepoint messages. */
571 static atomic_t tlstream_bytes_generated = {0};
572 #endif /* MALI_UNIT_TEST */
573
574 /*****************************************************************************/
575
576 /* Indicator of whether the timeline stream file descriptor is used. */
577 atomic_t kbase_tlstream_enabled = {0};
578
579 /*****************************************************************************/
580
581 /**
582 * kbasep_tlstream_get_timestamp - return timestamp
583 *
584 * Function returns timestamp value based on raw monotonic timer. Value will
585 * wrap around zero in case of overflow.
586 * Return: timestamp value
587 */
kbasep_tlstream_get_timestamp(void)588 static u64 kbasep_tlstream_get_timestamp(void)
589 {
590 struct timespec64 ts;
591 u64 timestamp;
592
593 ktime_get_raw_ts64(&ts);
594 timestamp = (u64)ts.tv_sec * NSECS_IN_SEC + ts.tv_nsec;
595 return timestamp;
596 }
597
598 /**
599 * kbasep_tlstream_write_bytes - write data to message buffer
600 * @buffer: buffer where data will be written
601 * @pos: position in the buffer where to place data
602 * @bytes: pointer to buffer holding data
603 * @len: length of data to be written
604 *
605 * Return: updated position in the buffer
606 */
kbasep_tlstream_write_bytes( char *buffer, size_t pos, const void *bytes, size_t len)607 static size_t kbasep_tlstream_write_bytes(
608 char *buffer,
609 size_t pos,
610 const void *bytes,
611 size_t len)
612 {
613 KBASE_DEBUG_ASSERT(buffer);
614 KBASE_DEBUG_ASSERT(bytes);
615
616 memcpy(&buffer[pos], bytes, len);
617
618 return pos + len;
619 }
620
621 /**
622 * kbasep_tlstream_write_string - write string to message buffer
623 * @buffer: buffer where data will be written
624 * @pos: position in the buffer where to place data
625 * @string: pointer to buffer holding the source string
626 * @max_write_size: number of bytes that can be stored in buffer
627 *
628 * Return: updated position in the buffer
629 */
kbasep_tlstream_write_string( char *buffer, size_t pos, const char *string, size_t max_write_size)630 static size_t kbasep_tlstream_write_string(
631 char *buffer,
632 size_t pos,
633 const char *string,
634 size_t max_write_size)
635 {
636 u32 string_len;
637
638 KBASE_DEBUG_ASSERT(buffer);
639 KBASE_DEBUG_ASSERT(string);
640 /* Timeline string consists of at least string length and nul
641 * terminator. */
642 KBASE_DEBUG_ASSERT(max_write_size >= sizeof(string_len) + sizeof(char));
643 max_write_size -= sizeof(string_len);
644
645 string_len = strlcpy(
646 &buffer[pos + sizeof(string_len)],
647 string,
648 max_write_size);
649 string_len += sizeof(char);
650
651 /* Make sure that the source string fit into the buffer. */
652 KBASE_DEBUG_ASSERT(string_len <= max_write_size);
653
654 /* Update string length. */
655 memcpy(&buffer[pos], &string_len, sizeof(string_len));
656
657 return pos + sizeof(string_len) + string_len;
658 }
659
660 /**
661 * kbasep_tlstream_write_timestamp - write timestamp to message buffer
662 * @buffer: buffer where data will be written
663 * @pos: position in the buffer where to place data
664 *
665 * Return: updated position in the buffer
666 */
kbasep_tlstream_write_timestamp(void *buffer, size_t pos)667 static size_t kbasep_tlstream_write_timestamp(void *buffer, size_t pos)
668 {
669 u64 timestamp = kbasep_tlstream_get_timestamp();
670
671 return kbasep_tlstream_write_bytes(
672 buffer, pos,
673 ×tamp, sizeof(timestamp));
674 }
675
676 /**
677 * kbasep_tlstream_put_bits - put bits in a word
678 * @word: pointer to the words being modified
679 * @value: value that shall be written to given position
680 * @bitpos: position where value shall be written (in bits)
681 * @bitlen: length of value (in bits)
682 */
kbasep_tlstream_put_bits( u32 *word, u32 value, unsigned int bitpos, unsigned int bitlen)683 static void kbasep_tlstream_put_bits(
684 u32 *word,
685 u32 value,
686 unsigned int bitpos,
687 unsigned int bitlen)
688 {
689 const u32 mask = ((1 << bitlen) - 1) << bitpos;
690
691 KBASE_DEBUG_ASSERT(word);
692 KBASE_DEBUG_ASSERT((0 != bitlen) && (32 >= bitlen));
693 KBASE_DEBUG_ASSERT((bitpos + bitlen) <= 32);
694
695 *word &= ~mask;
696 *word |= ((value << bitpos) & mask);
697 }
698
699 /**
700 * kbasep_tlstream_packet_header_setup - setup the packet header
701 * @buffer: pointer to the buffer
702 * @pkt_family: packet's family
703 * @pkt_type: packet's type
704 * @pkt_class: packet's class
705 * @stream_id: stream id
706 * @numbered: non-zero if this stream is numbered
707 *
708 * Function sets up immutable part of packet header in the given buffer.
709 */
kbasep_tlstream_packet_header_setup( char *buffer, enum tl_packet_family pkt_family, enum tl_packet_class pkt_class, enum tl_packet_type pkt_type, unsigned int stream_id, int numbered)710 static void kbasep_tlstream_packet_header_setup(
711 char *buffer,
712 enum tl_packet_family pkt_family,
713 enum tl_packet_class pkt_class,
714 enum tl_packet_type pkt_type,
715 unsigned int stream_id,
716 int numbered)
717 {
718 u32 word0 = 0;
719 u32 word1 = 0;
720
721 KBASE_DEBUG_ASSERT(buffer);
722 KBASE_DEBUG_ASSERT(pkt_family == TL_PACKET_FAMILY_TL);
723 KBASE_DEBUG_ASSERT(
724 (pkt_type == TL_PACKET_TYPE_HEADER) ||
725 (pkt_type == TL_PACKET_TYPE_SUMMARY) ||
726 (pkt_type == TL_PACKET_TYPE_BODY));
727 KBASE_DEBUG_ASSERT(
728 (pkt_class == TL_PACKET_CLASS_OBJ) ||
729 (pkt_class == TL_PACKET_CLASS_AUX));
730
731 kbasep_tlstream_put_bits(
732 &word0, pkt_family,
733 PACKET_FAMILY_POS, PACKET_FAMILY_LEN);
734 kbasep_tlstream_put_bits(
735 &word0, pkt_class,
736 PACKET_CLASS_POS, PACKET_CLASS_LEN);
737 kbasep_tlstream_put_bits(
738 &word0, pkt_type,
739 PACKET_TYPE_POS, PACKET_TYPE_LEN);
740 kbasep_tlstream_put_bits(
741 &word0, stream_id,
742 PACKET_STREAMID_POS, PACKET_STREAMID_LEN);
743
744 if (numbered)
745 kbasep_tlstream_put_bits(
746 &word1, 1,
747 PACKET_SEQBIT_POS, PACKET_SEQBIT_LEN);
748
749 memcpy(&buffer[0], &word0, sizeof(word0));
750 memcpy(&buffer[sizeof(word0)], &word1, sizeof(word1));
751 }
752
753 /**
754 * kbasep_tlstream_packet_header_update - update the packet header
755 * @buffer: pointer to the buffer
756 * @data_size: amount of data carried in this packet
757 *
758 * Function updates mutable part of packet header in the given buffer.
759 * Note that value of data_size must not including size of the header.
760 */
kbasep_tlstream_packet_header_update( char *buffer, size_t data_size)761 static void kbasep_tlstream_packet_header_update(
762 char *buffer,
763 size_t data_size)
764 {
765 u32 word0;
766 u32 word1;
767
768 KBASE_DEBUG_ASSERT(buffer);
769 CSTD_UNUSED(word0);
770
771 memcpy(&word1, &buffer[sizeof(word0)], sizeof(word1));
772
773 kbasep_tlstream_put_bits(
774 &word1, data_size,
775 PACKET_LENGTH_POS, PACKET_LENGTH_LEN);
776
777 memcpy(&buffer[sizeof(word0)], &word1, sizeof(word1));
778 }
779
780 /**
781 * kbasep_tlstream_packet_number_update - update the packet number
782 * @buffer: pointer to the buffer
783 * @counter: value of packet counter for this packet's stream
784 *
785 * Function updates packet number embedded within the packet placed in the
786 * given buffer.
787 */
kbasep_tlstream_packet_number_update(char *buffer, u32 counter)788 static void kbasep_tlstream_packet_number_update(char *buffer, u32 counter)
789 {
790 KBASE_DEBUG_ASSERT(buffer);
791
792 memcpy(&buffer[PACKET_HEADER_SIZE], &counter, sizeof(counter));
793 }
794
795 /**
796 * kbasep_timeline_stream_reset - reset stream
797 * @stream: pointer to the stream structure
798 *
799 * Function discards all pending messages and resets packet counters.
800 */
kbasep_timeline_stream_reset(struct tl_stream *stream)801 static void kbasep_timeline_stream_reset(struct tl_stream *stream)
802 {
803 unsigned int i;
804
805 for (i = 0; i < PACKET_COUNT; i++) {
806 if (stream->numbered)
807 atomic_set(
808 &stream->buffer[i].size,
809 PACKET_HEADER_SIZE +
810 PACKET_NUMBER_SIZE);
811 else
812 atomic_set(&stream->buffer[i].size, PACKET_HEADER_SIZE);
813 }
814
815 atomic_set(&stream->wbi, 0);
816 atomic_set(&stream->rbi, 0);
817 }
818
819 /**
820 * kbasep_timeline_stream_init - initialize timeline stream
821 * @stream: pointer to the stream structure
822 * @stream_type: stream type
823 */
kbasep_timeline_stream_init( struct tl_stream *stream, enum tl_stream_type stream_type)824 static void kbasep_timeline_stream_init(
825 struct tl_stream *stream,
826 enum tl_stream_type stream_type)
827 {
828 unsigned int i;
829
830 KBASE_DEBUG_ASSERT(stream);
831 KBASE_DEBUG_ASSERT(TL_STREAM_TYPE_COUNT > stream_type);
832
833 spin_lock_init(&stream->lock);
834
835 /* All packets carrying tracepoints shall be numbered. */
836 if (TL_PACKET_TYPE_BODY == tl_stream_cfg[stream_type].pkt_type)
837 stream->numbered = 1;
838 else
839 stream->numbered = 0;
840
841 for (i = 0; i < PACKET_COUNT; i++)
842 kbasep_tlstream_packet_header_setup(
843 stream->buffer[i].data,
844 tl_stream_cfg[stream_type].pkt_family,
845 tl_stream_cfg[stream_type].pkt_class,
846 tl_stream_cfg[stream_type].pkt_type,
847 tl_stream_cfg[stream_type].stream_id,
848 stream->numbered);
849
850 kbasep_timeline_stream_reset(tl_stream[stream_type]);
851 }
852
853 /**
854 * kbasep_timeline_stream_term - terminate timeline stream
855 * @stream: pointer to the stream structure
856 */
kbasep_timeline_stream_term(struct tl_stream *stream)857 static void kbasep_timeline_stream_term(struct tl_stream *stream)
858 {
859 KBASE_DEBUG_ASSERT(stream);
860 }
861
862 /**
863 * kbasep_tlstream_msgbuf_submit - submit packet to the user space
864 * @stream: pointer to the stream structure
865 * @wb_idx_raw: write buffer index
866 * @wb_size: length of data stored in current buffer
867 *
868 * Function updates currently written buffer with packet header. Then write
869 * index is incremented and buffer is handled to user space. Parameters
870 * of new buffer are returned using provided arguments.
871 *
872 * Return: length of data in new buffer
873 *
874 * Warning: User must update the stream structure with returned value.
875 */
kbasep_tlstream_msgbuf_submit( struct tl_stream *stream, unsigned int wb_idx_raw, unsigned int wb_size)876 static size_t kbasep_tlstream_msgbuf_submit(
877 struct tl_stream *stream,
878 unsigned int wb_idx_raw,
879 unsigned int wb_size)
880 {
881 unsigned int rb_idx_raw = atomic_read(&stream->rbi);
882 unsigned int wb_idx = wb_idx_raw % PACKET_COUNT;
883
884 /* Set stream as flushed. */
885 atomic_set(&stream->autoflush_counter, -1);
886
887 kbasep_tlstream_packet_header_update(
888 stream->buffer[wb_idx].data,
889 wb_size - PACKET_HEADER_SIZE);
890
891 if (stream->numbered)
892 kbasep_tlstream_packet_number_update(
893 stream->buffer[wb_idx].data,
894 wb_idx_raw);
895
896 /* Increasing write buffer index will expose this packet to the reader.
897 * As stream->lock is not taken on reader side we must make sure memory
898 * is updated correctly before this will happen. */
899 smp_wmb();
900 wb_idx_raw++;
901 atomic_set(&stream->wbi, wb_idx_raw);
902
903 /* Inform user that packets are ready for reading. */
904 wake_up_interruptible(&tl_event_queue);
905
906 /* Detect and mark overflow in this stream. */
907 if (PACKET_COUNT == wb_idx_raw - rb_idx_raw) {
908 /* Reader side depends on this increment to correctly handle
909 * overflows. The value shall be updated only if it was not
910 * modified by the reader. The data holding buffer will not be
911 * updated before stream->lock is released, however size of the
912 * buffer will. Make sure this increment is globally visible
913 * before information about selected write buffer size. */
914 atomic_cmpxchg(&stream->rbi, rb_idx_raw, rb_idx_raw + 1);
915 }
916
917 wb_size = PACKET_HEADER_SIZE;
918 if (stream->numbered)
919 wb_size += PACKET_NUMBER_SIZE;
920
921 return wb_size;
922 }
923
924 /**
925 * kbasep_tlstream_msgbuf_acquire - lock selected stream and reserves buffer
926 * @stream_type: type of the stream that shall be locked
927 * @msg_size: message size
928 * @flags: pointer to store flags passed back on stream release
929 *
930 * Function will lock the stream and reserve the number of bytes requested
931 * in msg_size for the user.
932 *
933 * Return: pointer to the buffer where message can be stored
934 *
935 * Warning: Stream must be released with kbasep_tlstream_msgbuf_release().
936 * Only atomic operations are allowed while stream is locked
937 * (i.e. do not use any operation that may sleep).
938 */
939 static char *kbasep_tlstream_msgbuf_acquire(
940 enum tl_stream_type stream_type,
941 size_t msg_size,
942 unsigned long *flags) __acquires(&stream->lock)
943 {
944 struct tl_stream *stream;
945 unsigned int wb_idx_raw;
946 unsigned int wb_idx;
947 size_t wb_size;
948
949 KBASE_DEBUG_ASSERT(TL_STREAM_TYPE_COUNT > stream_type);
950 KBASE_DEBUG_ASSERT(
951 PACKET_SIZE - PACKET_HEADER_SIZE - PACKET_NUMBER_SIZE >=
952 msg_size);
953
954 stream = tl_stream[stream_type];
955
956 spin_lock_irqsave(&stream->lock, *flags);
957
958 wb_idx_raw = atomic_read(&stream->wbi);
959 wb_idx = wb_idx_raw % PACKET_COUNT;
960 wb_size = atomic_read(&stream->buffer[wb_idx].size);
961
962 /* Select next buffer if data will not fit into current one. */
963 if (PACKET_SIZE < wb_size + msg_size) {
964 wb_size = kbasep_tlstream_msgbuf_submit(
965 stream, wb_idx_raw, wb_size);
966 wb_idx = (wb_idx_raw + 1) % PACKET_COUNT;
967 }
968
969 /* Reserve space in selected buffer. */
970 atomic_set(&stream->buffer[wb_idx].size, wb_size + msg_size);
971
972 #if MALI_UNIT_TEST
973 atomic_add(msg_size, &tlstream_bytes_generated);
974 #endif /* MALI_UNIT_TEST */
975
976 return &stream->buffer[wb_idx].data[wb_size];
977 }
978
979 /**
980 * kbasep_tlstream_msgbuf_release - unlock selected stream
981 * @stream_type: type of the stream that shall be locked
982 * @flags: value obtained during stream acquire
983 *
984 * Function releases stream that has been previously locked with a call to
985 * kbasep_tlstream_msgbuf_acquire().
986 */
987 static void kbasep_tlstream_msgbuf_release(
988 enum tl_stream_type stream_type,
989 unsigned long flags) __releases(&stream->lock)
990 {
991 struct tl_stream *stream;
992
993 KBASE_DEBUG_ASSERT(TL_STREAM_TYPE_COUNT > stream_type);
994
995 stream = tl_stream[stream_type];
996
997 /* Mark stream as containing unflushed data. */
998 atomic_set(&stream->autoflush_counter, 0);
999
1000 spin_unlock_irqrestore(&stream->lock, flags);
1001 }
1002
1003 /*****************************************************************************/
1004
1005 /**
1006 * kbasep_tlstream_flush_stream - flush stream
1007 * @stype: type of stream to be flushed
1008 *
1009 * Flush pending data in timeline stream.
1010 */
kbasep_tlstream_flush_stream(enum tl_stream_type stype)1011 static void kbasep_tlstream_flush_stream(enum tl_stream_type stype)
1012 {
1013 struct tl_stream *stream = tl_stream[stype];
1014 unsigned long flags;
1015 unsigned int wb_idx_raw;
1016 unsigned int wb_idx;
1017 size_t wb_size;
1018 size_t min_size = PACKET_HEADER_SIZE;
1019
1020 if (stream->numbered)
1021 min_size += PACKET_NUMBER_SIZE;
1022
1023 spin_lock_irqsave(&stream->lock, flags);
1024
1025 wb_idx_raw = atomic_read(&stream->wbi);
1026 wb_idx = wb_idx_raw % PACKET_COUNT;
1027 wb_size = atomic_read(&stream->buffer[wb_idx].size);
1028
1029 if (wb_size > min_size) {
1030 wb_size = kbasep_tlstream_msgbuf_submit(
1031 stream, wb_idx_raw, wb_size);
1032 wb_idx = (wb_idx_raw + 1) % PACKET_COUNT;
1033 atomic_set(&stream->buffer[wb_idx].size, wb_size);
1034 }
1035 spin_unlock_irqrestore(&stream->lock, flags);
1036 }
1037
1038 /**
1039 * kbasep_tlstream_autoflush_timer_callback - autoflush timer callback
1040 * @data: unused
1041 *
1042 * Timer is executed periodically to check if any of the stream contains
1043 * buffer ready to be submitted to user space.
1044 */
kbasep_tlstream_autoflush_timer_callback(struct timer_list *t)1045 static void kbasep_tlstream_autoflush_timer_callback(struct timer_list *t)
1046 {
1047 enum tl_stream_type stype;
1048 int rcode;
1049
1050 CSTD_UNUSED(t);
1051
1052 for (stype = 0; stype < TL_STREAM_TYPE_COUNT; stype++) {
1053 struct tl_stream *stream = tl_stream[stype];
1054 unsigned long flags;
1055 unsigned int wb_idx_raw;
1056 unsigned int wb_idx;
1057 size_t wb_size;
1058 size_t min_size = PACKET_HEADER_SIZE;
1059
1060 int af_cnt = atomic_read(&stream->autoflush_counter);
1061
1062 /* Check if stream contain unflushed data. */
1063 if (0 > af_cnt)
1064 continue;
1065
1066 /* Check if stream should be flushed now. */
1067 if (af_cnt != atomic_cmpxchg(
1068 &stream->autoflush_counter,
1069 af_cnt,
1070 af_cnt + 1))
1071 continue;
1072 if (!af_cnt)
1073 continue;
1074
1075 /* Autoflush this stream. */
1076 if (stream->numbered)
1077 min_size += PACKET_NUMBER_SIZE;
1078
1079 spin_lock_irqsave(&stream->lock, flags);
1080
1081 wb_idx_raw = atomic_read(&stream->wbi);
1082 wb_idx = wb_idx_raw % PACKET_COUNT;
1083 wb_size = atomic_read(&stream->buffer[wb_idx].size);
1084
1085 if (wb_size > min_size) {
1086 wb_size = kbasep_tlstream_msgbuf_submit(
1087 stream, wb_idx_raw, wb_size);
1088 wb_idx = (wb_idx_raw + 1) % PACKET_COUNT;
1089 atomic_set(&stream->buffer[wb_idx].size,
1090 wb_size);
1091 }
1092 spin_unlock_irqrestore(&stream->lock, flags);
1093 }
1094
1095 if (atomic_read(&autoflush_timer_active))
1096 rcode = mod_timer(
1097 &autoflush_timer,
1098 jiffies + msecs_to_jiffies(AUTOFLUSH_INTERVAL));
1099 CSTD_UNUSED(rcode);
1100 }
1101
1102 /**
1103 * kbasep_tlstream_packet_pending - check timeline streams for pending packets
1104 * @stype: pointer to variable where stream type will be placed
1105 * @rb_idx_raw: pointer to variable where read buffer index will be placed
1106 *
1107 * Function checks all streams for pending packets. It will stop as soon as
1108 * packet ready to be submitted to user space is detected. Variables under
1109 * pointers, passed as the parameters to this function will be updated with
1110 * values pointing to right stream and buffer.
1111 *
1112 * Return: non-zero if any of timeline streams has at last one packet ready
1113 */
kbasep_tlstream_packet_pending( enum tl_stream_type *stype, unsigned int *rb_idx_raw)1114 static int kbasep_tlstream_packet_pending(
1115 enum tl_stream_type *stype,
1116 unsigned int *rb_idx_raw)
1117 {
1118 int pending = 0;
1119
1120 KBASE_DEBUG_ASSERT(stype);
1121 KBASE_DEBUG_ASSERT(rb_idx_raw);
1122
1123 for (
1124 *stype = 0;
1125 (*stype < TL_STREAM_TYPE_COUNT) && !pending;
1126 (*stype)++) {
1127 if (NULL != tl_stream[*stype]) {
1128 *rb_idx_raw = atomic_read(&tl_stream[*stype]->rbi);
1129 /* Read buffer index may be updated by writer in case of
1130 * overflow. Read and write buffer indexes must be
1131 * loaded in correct order. */
1132 smp_rmb();
1133 if (atomic_read(&tl_stream[*stype]->wbi) != *rb_idx_raw)
1134 pending = 1;
1135 }
1136 }
1137 (*stype)--;
1138
1139 return pending;
1140 }
1141
1142 /**
1143 * kbasep_tlstream_read - copy data from streams to buffer provided by user
1144 * @filp: pointer to file structure (unused)
1145 * @buffer: pointer to the buffer provided by user
1146 * @size: maximum amount of data that can be stored in the buffer
1147 * @f_pos: pointer to file offset (unused)
1148 *
1149 * Return: number of bytes stored in the buffer
1150 */
kbasep_tlstream_read( struct file *filp, char __user *buffer, size_t size, loff_t *f_pos)1151 static ssize_t kbasep_tlstream_read(
1152 struct file *filp,
1153 char __user *buffer,
1154 size_t size,
1155 loff_t *f_pos)
1156 {
1157 ssize_t copy_len = 0;
1158
1159 KBASE_DEBUG_ASSERT(filp);
1160 KBASE_DEBUG_ASSERT(f_pos);
1161
1162 if (!buffer)
1163 return -EINVAL;
1164
1165 if ((0 > *f_pos) || (PACKET_SIZE > size))
1166 return -EINVAL;
1167
1168 mutex_lock(&tl_reader_lock);
1169
1170 while (copy_len < size) {
1171 enum tl_stream_type stype;
1172 unsigned int rb_idx_raw = 0;
1173 unsigned int rb_idx;
1174 size_t rb_size;
1175
1176 /* If we don't have any data yet, wait for packet to be
1177 * submitted. If we already read some packets and there is no
1178 * packet pending return back to user. */
1179 if (0 < copy_len) {
1180 if (!kbasep_tlstream_packet_pending(
1181 &stype,
1182 &rb_idx_raw))
1183 break;
1184 } else {
1185 if (wait_event_interruptible(
1186 tl_event_queue,
1187 kbasep_tlstream_packet_pending(
1188 &stype,
1189 &rb_idx_raw))) {
1190 copy_len = -ERESTARTSYS;
1191 break;
1192 }
1193 }
1194
1195 /* Check if this packet fits into the user buffer.
1196 * If so copy its content. */
1197 rb_idx = rb_idx_raw % PACKET_COUNT;
1198 rb_size = atomic_read(&tl_stream[stype]->buffer[rb_idx].size);
1199 if (rb_size > size - copy_len)
1200 break;
1201 if (copy_to_user(
1202 &buffer[copy_len],
1203 tl_stream[stype]->buffer[rb_idx].data,
1204 rb_size)) {
1205 copy_len = -EFAULT;
1206 break;
1207 }
1208
1209 /* If the rbi still points to the packet we just processed
1210 * then there was no overflow so we add the copied size to
1211 * copy_len and move rbi on to the next packet
1212 */
1213 smp_rmb();
1214 if (atomic_read(&tl_stream[stype]->rbi) == rb_idx_raw) {
1215 copy_len += rb_size;
1216 atomic_inc(&tl_stream[stype]->rbi);
1217
1218 #if MALI_UNIT_TEST
1219 atomic_add(rb_size, &tlstream_bytes_collected);
1220 #endif /* MALI_UNIT_TEST */
1221 }
1222 }
1223
1224 mutex_unlock(&tl_reader_lock);
1225
1226 return copy_len;
1227 }
1228
1229 /**
1230 * kbasep_tlstream_poll - poll timeline stream for packets
1231 * @filp: pointer to file structure
1232 * @wait: pointer to poll table
1233 * Return: POLLIN if data can be read without blocking, otherwise zero
1234 */
kbasep_tlstream_poll(struct file *filp, poll_table *wait)1235 static unsigned int kbasep_tlstream_poll(struct file *filp, poll_table *wait)
1236 {
1237 enum tl_stream_type stream_type;
1238 unsigned int rb_idx;
1239
1240 KBASE_DEBUG_ASSERT(filp);
1241 KBASE_DEBUG_ASSERT(wait);
1242
1243 poll_wait(filp, &tl_event_queue, wait);
1244 if (kbasep_tlstream_packet_pending(&stream_type, &rb_idx))
1245 return POLLIN;
1246 return 0;
1247 }
1248
1249 /**
1250 * kbasep_tlstream_release - release timeline stream descriptor
1251 * @inode: pointer to inode structure
1252 * @filp: pointer to file structure
1253 *
1254 * Return always return zero
1255 */
kbasep_tlstream_release(struct inode *inode, struct file *filp)1256 static int kbasep_tlstream_release(struct inode *inode, struct file *filp)
1257 {
1258 KBASE_DEBUG_ASSERT(inode);
1259 KBASE_DEBUG_ASSERT(filp);
1260 CSTD_UNUSED(inode);
1261 CSTD_UNUSED(filp);
1262
1263 /* Stop autoflush timer before releasing access to streams. */
1264 atomic_set(&autoflush_timer_active, 0);
1265 del_timer_sync(&autoflush_timer);
1266
1267 atomic_set(&kbase_tlstream_enabled, 0);
1268 return 0;
1269 }
1270
1271 /**
1272 * kbasep_tlstream_timeline_header - prepare timeline header stream packet
1273 * @stream_type: type of the stream that will carry header data
1274 * @tp_desc: pointer to array with tracepoint descriptors
1275 * @tp_count: number of descriptors in the given array
1276 *
1277 * Functions fills in information about tracepoints stored in body stream
1278 * associated with this header stream.
1279 */
kbasep_tlstream_timeline_header( enum tl_stream_type stream_type, const struct tp_desc *tp_desc, u32 tp_count)1280 static void kbasep_tlstream_timeline_header(
1281 enum tl_stream_type stream_type,
1282 const struct tp_desc *tp_desc,
1283 u32 tp_count)
1284 {
1285 const u8 tv = SWTRACE_VERSION; /* protocol version */
1286 const u8 ps = sizeof(void *); /* pointer size */
1287 size_t msg_size = sizeof(tv) + sizeof(ps) + sizeof(tp_count);
1288 char *buffer;
1289 size_t pos = 0;
1290 unsigned long flags;
1291 unsigned int i;
1292
1293 KBASE_DEBUG_ASSERT(TL_STREAM_TYPE_COUNT > stream_type);
1294 KBASE_DEBUG_ASSERT(tp_desc);
1295
1296 /* Calculate the size of the timeline message. */
1297 for (i = 0; i < tp_count; i++) {
1298 msg_size += sizeof(tp_desc[i].id);
1299 msg_size +=
1300 strnlen(tp_desc[i].id_str, STRLEN_MAX) +
1301 sizeof(char) + sizeof(u32);
1302 msg_size +=
1303 strnlen(tp_desc[i].name, STRLEN_MAX) +
1304 sizeof(char) + sizeof(u32);
1305 msg_size +=
1306 strnlen(tp_desc[i].arg_types, STRLEN_MAX) +
1307 sizeof(char) + sizeof(u32);
1308 msg_size +=
1309 strnlen(tp_desc[i].arg_names, STRLEN_MAX) +
1310 sizeof(char) + sizeof(u32);
1311 }
1312
1313 KBASE_DEBUG_ASSERT(PACKET_SIZE - PACKET_HEADER_SIZE >= msg_size);
1314
1315 buffer = kbasep_tlstream_msgbuf_acquire(stream_type, msg_size, &flags);
1316 KBASE_DEBUG_ASSERT(buffer);
1317
1318 pos = kbasep_tlstream_write_bytes(buffer, pos, &tv, sizeof(tv));
1319 pos = kbasep_tlstream_write_bytes(buffer, pos, &ps, sizeof(ps));
1320 pos = kbasep_tlstream_write_bytes(
1321 buffer, pos, &tp_count, sizeof(tp_count));
1322
1323 for (i = 0; i < tp_count; i++) {
1324 pos = kbasep_tlstream_write_bytes(
1325 buffer, pos,
1326 &tp_desc[i].id, sizeof(tp_desc[i].id));
1327 pos = kbasep_tlstream_write_string(
1328 buffer, pos,
1329 tp_desc[i].id_str, msg_size - pos);
1330 pos = kbasep_tlstream_write_string(
1331 buffer, pos,
1332 tp_desc[i].name, msg_size - pos);
1333 pos = kbasep_tlstream_write_string(
1334 buffer, pos,
1335 tp_desc[i].arg_types, msg_size - pos);
1336 pos = kbasep_tlstream_write_string(
1337 buffer, pos,
1338 tp_desc[i].arg_names, msg_size - pos);
1339 }
1340
1341 KBASE_DEBUG_ASSERT(msg_size == pos);
1342
1343 kbasep_tlstream_msgbuf_release(stream_type, flags);
1344
1345 /* We don't expect any more data to be read in this stream.
1346 * As header stream must be read before its associated body stream,
1347 * make this packet visible to the user straightaway. */
1348 kbasep_tlstream_flush_stream(stream_type);
1349 }
1350
1351 /*****************************************************************************/
1352
kbase_tlstream_init(void)1353 int kbase_tlstream_init(void)
1354 {
1355 enum tl_stream_type i;
1356
1357 /* Prepare stream structures. */
1358 for (i = 0; i < TL_STREAM_TYPE_COUNT; i++) {
1359 tl_stream[i] = kmalloc(sizeof(**tl_stream), GFP_KERNEL);
1360 if (!tl_stream[i])
1361 break;
1362 kbasep_timeline_stream_init(tl_stream[i], i);
1363 }
1364 if (TL_STREAM_TYPE_COUNT > i) {
1365 for (; i > 0; i--) {
1366 kbasep_timeline_stream_term(tl_stream[i - 1]);
1367 kfree(tl_stream[i - 1]);
1368 }
1369 return -ENOMEM;
1370 }
1371
1372 /* Initialize autoflush timer. */
1373 atomic_set(&autoflush_timer_active, 0);
1374 timer_setup(&autoflush_timer,
1375 kbasep_tlstream_autoflush_timer_callback,
1376 0);
1377
1378 return 0;
1379 }
1380
kbase_tlstream_term(void)1381 void kbase_tlstream_term(void)
1382 {
1383 enum tl_stream_type i;
1384
1385 for (i = 0; i < TL_STREAM_TYPE_COUNT; i++) {
1386 kbasep_timeline_stream_term(tl_stream[i]);
1387 kfree(tl_stream[i]);
1388 }
1389 }
1390
kbase_create_timeline_objects(struct kbase_context *kctx)1391 static void kbase_create_timeline_objects(struct kbase_context *kctx)
1392 {
1393 struct kbase_device *kbdev = kctx->kbdev;
1394 unsigned int lpu_id;
1395 unsigned int as_nr;
1396 struct kbasep_kctx_list_element *element;
1397
1398 /* Create LPU objects. */
1399 for (lpu_id = 0; lpu_id < kbdev->gpu_props.num_job_slots; lpu_id++) {
1400 u32 *lpu =
1401 &kbdev->gpu_props.props.raw_props.js_features[lpu_id];
1402 KBASE_TLSTREAM_TL_SUMMARY_NEW_LPU(lpu, lpu_id, *lpu);
1403 }
1404
1405 /* Create Address Space objects. */
1406 for (as_nr = 0; as_nr < kbdev->nr_hw_address_spaces; as_nr++)
1407 KBASE_TLSTREAM_TL_SUMMARY_NEW_AS(&kbdev->as[as_nr], as_nr);
1408
1409 /* Create GPU object and make it retain all LPUs and address spaces. */
1410 KBASE_TLSTREAM_TL_SUMMARY_NEW_GPU(
1411 kbdev,
1412 kbdev->gpu_props.props.raw_props.gpu_id,
1413 kbdev->gpu_props.num_cores);
1414
1415 for (lpu_id = 0; lpu_id < kbdev->gpu_props.num_job_slots; lpu_id++) {
1416 void *lpu =
1417 &kbdev->gpu_props.props.raw_props.js_features[lpu_id];
1418 KBASE_TLSTREAM_TL_SUMMARY_LIFELINK_LPU_GPU(lpu, kbdev);
1419 }
1420 for (as_nr = 0; as_nr < kbdev->nr_hw_address_spaces; as_nr++)
1421 KBASE_TLSTREAM_TL_SUMMARY_LIFELINK_AS_GPU(
1422 &kbdev->as[as_nr],
1423 kbdev);
1424
1425 /* Create object for each known context. */
1426 mutex_lock(&kbdev->kctx_list_lock);
1427 list_for_each_entry(element, &kbdev->kctx_list, link) {
1428 KBASE_TLSTREAM_TL_SUMMARY_NEW_CTX(
1429 element->kctx,
1430 (u32)(element->kctx->id),
1431 (u32)(element->kctx->tgid));
1432 }
1433 /* Before releasing the lock, reset body stream buffers.
1434 * This will prevent context creation message to be directed to both
1435 * summary and body stream.
1436 */
1437 kbase_tlstream_reset_body_streams();
1438 mutex_unlock(&kbdev->kctx_list_lock);
1439 /* Static object are placed into summary packet that needs to be
1440 * transmitted first. Flush all streams to make it available to
1441 * user space.
1442 */
1443 kbase_tlstream_flush_streams();
1444 }
1445
kbase_tlstream_acquire(struct kbase_context *kctx, u32 flags)1446 int kbase_tlstream_acquire(struct kbase_context *kctx, u32 flags)
1447 {
1448 int ret;
1449 u32 tlstream_enabled = TLSTREAM_ENABLED | flags;
1450
1451 if (0 == atomic_cmpxchg(&kbase_tlstream_enabled, 0, tlstream_enabled)) {
1452 int rcode;
1453
1454 ret = anon_inode_getfd(
1455 "[mali_tlstream]",
1456 &kbasep_tlstream_fops,
1457 kctx,
1458 O_RDONLY | O_CLOEXEC);
1459 if (ret < 0) {
1460 atomic_set(&kbase_tlstream_enabled, 0);
1461 return ret;
1462 }
1463
1464 /* Reset and initialize header streams. */
1465 kbasep_timeline_stream_reset(
1466 tl_stream[TL_STREAM_TYPE_OBJ_HEADER]);
1467 kbasep_timeline_stream_reset(
1468 tl_stream[TL_STREAM_TYPE_OBJ_SUMMARY]);
1469 kbasep_timeline_stream_reset(
1470 tl_stream[TL_STREAM_TYPE_AUX_HEADER]);
1471 kbasep_tlstream_timeline_header(
1472 TL_STREAM_TYPE_OBJ_HEADER,
1473 tp_desc_obj,
1474 ARRAY_SIZE(tp_desc_obj));
1475 kbasep_tlstream_timeline_header(
1476 TL_STREAM_TYPE_AUX_HEADER,
1477 tp_desc_aux,
1478 ARRAY_SIZE(tp_desc_aux));
1479
1480 /* Start autoflush timer. */
1481 atomic_set(&autoflush_timer_active, 1);
1482 rcode = mod_timer(
1483 &autoflush_timer,
1484 jiffies + msecs_to_jiffies(AUTOFLUSH_INTERVAL));
1485 CSTD_UNUSED(rcode);
1486
1487 /* If job dumping is enabled, readjust the software event's
1488 * timeout as the default value of 3 seconds is often
1489 * insufficient. */
1490 if (flags & BASE_TLSTREAM_JOB_DUMPING_ENABLED) {
1491 dev_info(kctx->kbdev->dev,
1492 "Job dumping is enabled, readjusting the software event's timeout\n");
1493 atomic_set(&kctx->kbdev->js_data.soft_job_timeout_ms,
1494 1800000);
1495 }
1496
1497 /* Summary stream was cleared during acquire.
1498 * Create static timeline objects that will be
1499 * read by client.
1500 */
1501 kbase_create_timeline_objects(kctx);
1502
1503 } else {
1504 ret = -EBUSY;
1505 }
1506
1507 return ret;
1508 }
1509
kbase_tlstream_flush_streams(void)1510 void kbase_tlstream_flush_streams(void)
1511 {
1512 enum tl_stream_type stype;
1513
1514 for (stype = 0; stype < TL_STREAM_TYPE_COUNT; stype++)
1515 kbasep_tlstream_flush_stream(stype);
1516 }
1517
kbase_tlstream_reset_body_streams(void)1518 void kbase_tlstream_reset_body_streams(void)
1519 {
1520 kbasep_timeline_stream_reset(
1521 tl_stream[TL_STREAM_TYPE_OBJ]);
1522 kbasep_timeline_stream_reset(
1523 tl_stream[TL_STREAM_TYPE_AUX]);
1524 }
1525
1526 #if MALI_UNIT_TEST
kbase_tlstream_stats(u32 *bytes_collected, u32 *bytes_generated)1527 void kbase_tlstream_stats(u32 *bytes_collected, u32 *bytes_generated)
1528 {
1529 KBASE_DEBUG_ASSERT(bytes_collected);
1530 KBASE_DEBUG_ASSERT(bytes_generated);
1531 *bytes_collected = atomic_read(&tlstream_bytes_collected);
1532 *bytes_generated = atomic_read(&tlstream_bytes_generated);
1533 }
1534 #endif /* MALI_UNIT_TEST */
1535
1536 /*****************************************************************************/
1537
__kbase_tlstream_tl_summary_new_ctx(void *context, u32 nr, u32 tgid)1538 void __kbase_tlstream_tl_summary_new_ctx(void *context, u32 nr, u32 tgid)
1539 {
1540 const u32 msg_id = KBASE_TL_NEW_CTX;
1541 const size_t msg_size =
1542 sizeof(msg_id) + sizeof(u64) + sizeof(context) + sizeof(nr) +
1543 sizeof(tgid);
1544 unsigned long flags;
1545 char *buffer;
1546 size_t pos = 0;
1547
1548 buffer = kbasep_tlstream_msgbuf_acquire(
1549 TL_STREAM_TYPE_OBJ_SUMMARY,
1550 msg_size, &flags);
1551 KBASE_DEBUG_ASSERT(buffer);
1552
1553 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
1554 pos = kbasep_tlstream_write_timestamp(buffer, pos);
1555 pos = kbasep_tlstream_write_bytes(
1556 buffer, pos, &context, sizeof(context));
1557 pos = kbasep_tlstream_write_bytes(
1558 buffer, pos, &nr, sizeof(nr));
1559 pos = kbasep_tlstream_write_bytes(
1560 buffer, pos, &tgid, sizeof(tgid));
1561
1562 KBASE_DEBUG_ASSERT(msg_size == pos);
1563
1564 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_OBJ_SUMMARY, flags);
1565 }
1566
__kbase_tlstream_tl_summary_new_gpu(void *gpu, u32 id, u32 core_count)1567 void __kbase_tlstream_tl_summary_new_gpu(void *gpu, u32 id, u32 core_count)
1568 {
1569 const u32 msg_id = KBASE_TL_NEW_GPU;
1570 const size_t msg_size =
1571 sizeof(msg_id) + sizeof(u64) + sizeof(gpu) + sizeof(id) +
1572 sizeof(core_count);
1573 unsigned long flags;
1574 char *buffer;
1575 size_t pos = 0;
1576
1577 buffer = kbasep_tlstream_msgbuf_acquire(
1578 TL_STREAM_TYPE_OBJ_SUMMARY,
1579 msg_size, &flags);
1580 KBASE_DEBUG_ASSERT(buffer);
1581
1582 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
1583 pos = kbasep_tlstream_write_timestamp(buffer, pos);
1584 pos = kbasep_tlstream_write_bytes(
1585 buffer, pos, &gpu, sizeof(gpu));
1586 pos = kbasep_tlstream_write_bytes(
1587 buffer, pos, &id, sizeof(id));
1588 pos = kbasep_tlstream_write_bytes(
1589 buffer, pos, &core_count, sizeof(core_count));
1590 KBASE_DEBUG_ASSERT(msg_size == pos);
1591
1592 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_OBJ_SUMMARY, flags);
1593 }
1594
__kbase_tlstream_tl_summary_new_lpu(void *lpu, u32 nr, u32 fn)1595 void __kbase_tlstream_tl_summary_new_lpu(void *lpu, u32 nr, u32 fn)
1596 {
1597 const u32 msg_id = KBASE_TL_NEW_LPU;
1598 const size_t msg_size =
1599 sizeof(msg_id) + sizeof(u64) + sizeof(lpu) + sizeof(nr) +
1600 sizeof(fn);
1601 unsigned long flags;
1602 char *buffer;
1603 size_t pos = 0;
1604
1605 buffer = kbasep_tlstream_msgbuf_acquire(
1606 TL_STREAM_TYPE_OBJ_SUMMARY,
1607 msg_size, &flags);
1608 KBASE_DEBUG_ASSERT(buffer);
1609
1610 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
1611 pos = kbasep_tlstream_write_timestamp(buffer, pos);
1612 pos = kbasep_tlstream_write_bytes(
1613 buffer, pos, &lpu, sizeof(lpu));
1614 pos = kbasep_tlstream_write_bytes(
1615 buffer, pos, &nr, sizeof(nr));
1616 pos = kbasep_tlstream_write_bytes(
1617 buffer, pos, &fn, sizeof(fn));
1618 KBASE_DEBUG_ASSERT(msg_size == pos);
1619
1620 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_OBJ_SUMMARY, flags);
1621 }
1622
__kbase_tlstream_tl_summary_lifelink_lpu_gpu(void *lpu, void *gpu)1623 void __kbase_tlstream_tl_summary_lifelink_lpu_gpu(void *lpu, void *gpu)
1624 {
1625 const u32 msg_id = KBASE_TL_LIFELINK_LPU_GPU;
1626 const size_t msg_size =
1627 sizeof(msg_id) + sizeof(u64) + sizeof(lpu) + sizeof(gpu);
1628 unsigned long flags;
1629 char *buffer;
1630 size_t pos = 0;
1631
1632 buffer = kbasep_tlstream_msgbuf_acquire(
1633 TL_STREAM_TYPE_OBJ_SUMMARY,
1634 msg_size, &flags);
1635 KBASE_DEBUG_ASSERT(buffer);
1636
1637 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
1638 pos = kbasep_tlstream_write_timestamp(buffer, pos);
1639 pos = kbasep_tlstream_write_bytes(
1640 buffer, pos, &lpu, sizeof(lpu));
1641 pos = kbasep_tlstream_write_bytes(
1642 buffer, pos, &gpu, sizeof(gpu));
1643 KBASE_DEBUG_ASSERT(msg_size == pos);
1644
1645 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_OBJ_SUMMARY, flags);
1646 }
1647
__kbase_tlstream_tl_summary_new_as(void *as, u32 nr)1648 void __kbase_tlstream_tl_summary_new_as(void *as, u32 nr)
1649 {
1650 const u32 msg_id = KBASE_TL_NEW_AS;
1651 const size_t msg_size =
1652 sizeof(msg_id) + sizeof(u64) + sizeof(as) + sizeof(nr);
1653 unsigned long flags;
1654 char *buffer;
1655 size_t pos = 0;
1656
1657 buffer = kbasep_tlstream_msgbuf_acquire(
1658 TL_STREAM_TYPE_OBJ_SUMMARY,
1659 msg_size, &flags);
1660 KBASE_DEBUG_ASSERT(buffer);
1661
1662 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
1663 pos = kbasep_tlstream_write_timestamp(buffer, pos);
1664 pos = kbasep_tlstream_write_bytes(
1665 buffer, pos, &as, sizeof(as));
1666 pos = kbasep_tlstream_write_bytes(
1667 buffer, pos, &nr, sizeof(nr));
1668 KBASE_DEBUG_ASSERT(msg_size == pos);
1669
1670 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_OBJ_SUMMARY, flags);
1671 }
1672
__kbase_tlstream_tl_summary_lifelink_as_gpu(void *as, void *gpu)1673 void __kbase_tlstream_tl_summary_lifelink_as_gpu(void *as, void *gpu)
1674 {
1675 const u32 msg_id = KBASE_TL_LIFELINK_AS_GPU;
1676 const size_t msg_size =
1677 sizeof(msg_id) + sizeof(u64) + sizeof(as) + sizeof(gpu);
1678 unsigned long flags;
1679 char *buffer;
1680 size_t pos = 0;
1681
1682 buffer = kbasep_tlstream_msgbuf_acquire(
1683 TL_STREAM_TYPE_OBJ_SUMMARY,
1684 msg_size, &flags);
1685 KBASE_DEBUG_ASSERT(buffer);
1686
1687 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
1688 pos = kbasep_tlstream_write_timestamp(buffer, pos);
1689 pos = kbasep_tlstream_write_bytes(
1690 buffer, pos, &as, sizeof(as));
1691 pos = kbasep_tlstream_write_bytes(
1692 buffer, pos, &gpu, sizeof(gpu));
1693 KBASE_DEBUG_ASSERT(msg_size == pos);
1694
1695 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_OBJ_SUMMARY, flags);
1696 }
1697
1698 /*****************************************************************************/
1699
__kbase_tlstream_tl_new_ctx(void *context, u32 nr, u32 tgid)1700 void __kbase_tlstream_tl_new_ctx(void *context, u32 nr, u32 tgid)
1701 {
1702 const u32 msg_id = KBASE_TL_NEW_CTX;
1703 const size_t msg_size =
1704 sizeof(msg_id) + sizeof(u64) + sizeof(context) + sizeof(nr) +
1705 sizeof(tgid);
1706 unsigned long flags;
1707 char *buffer;
1708 size_t pos = 0;
1709
1710 buffer = kbasep_tlstream_msgbuf_acquire(
1711 TL_STREAM_TYPE_OBJ,
1712 msg_size, &flags);
1713 KBASE_DEBUG_ASSERT(buffer);
1714
1715 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
1716 pos = kbasep_tlstream_write_timestamp(buffer, pos);
1717 pos = kbasep_tlstream_write_bytes(
1718 buffer, pos, &context, sizeof(context));
1719 pos = kbasep_tlstream_write_bytes(
1720 buffer, pos, &nr, sizeof(nr));
1721 pos = kbasep_tlstream_write_bytes(
1722 buffer, pos, &tgid, sizeof(tgid));
1723 KBASE_DEBUG_ASSERT(msg_size == pos);
1724
1725 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_OBJ, flags);
1726 }
1727
__kbase_tlstream_tl_new_atom(void *atom, u32 nr)1728 void __kbase_tlstream_tl_new_atom(void *atom, u32 nr)
1729 {
1730 const u32 msg_id = KBASE_TL_NEW_ATOM;
1731 const size_t msg_size = sizeof(msg_id) + sizeof(u64) + sizeof(atom) +
1732 sizeof(nr);
1733 unsigned long flags;
1734 char *buffer;
1735 size_t pos = 0;
1736
1737 buffer = kbasep_tlstream_msgbuf_acquire(
1738 TL_STREAM_TYPE_OBJ,
1739 msg_size, &flags);
1740 KBASE_DEBUG_ASSERT(buffer);
1741
1742 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
1743 pos = kbasep_tlstream_write_timestamp(buffer, pos);
1744 pos = kbasep_tlstream_write_bytes(
1745 buffer, pos, &atom, sizeof(atom));
1746 pos = kbasep_tlstream_write_bytes(
1747 buffer, pos, &nr, sizeof(nr));
1748 KBASE_DEBUG_ASSERT(msg_size == pos);
1749
1750 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_OBJ, flags);
1751 }
1752
__kbase_tlstream_tl_del_ctx(void *context)1753 void __kbase_tlstream_tl_del_ctx(void *context)
1754 {
1755 const u32 msg_id = KBASE_TL_DEL_CTX;
1756 const size_t msg_size =
1757 sizeof(msg_id) + sizeof(u64) + sizeof(context);
1758 unsigned long flags;
1759 char *buffer;
1760 size_t pos = 0;
1761
1762 buffer = kbasep_tlstream_msgbuf_acquire(
1763 TL_STREAM_TYPE_OBJ,
1764 msg_size, &flags);
1765 KBASE_DEBUG_ASSERT(buffer);
1766
1767 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
1768 pos = kbasep_tlstream_write_timestamp(buffer, pos);
1769 pos = kbasep_tlstream_write_bytes(
1770 buffer, pos, &context, sizeof(context));
1771 KBASE_DEBUG_ASSERT(msg_size == pos);
1772
1773 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_OBJ, flags);
1774 }
1775
__kbase_tlstream_tl_del_atom(void *atom)1776 void __kbase_tlstream_tl_del_atom(void *atom)
1777 {
1778 const u32 msg_id = KBASE_TL_DEL_ATOM;
1779 const size_t msg_size =
1780 sizeof(msg_id) + sizeof(u64) + sizeof(atom);
1781 unsigned long flags;
1782 char *buffer;
1783 size_t pos = 0;
1784
1785 buffer = kbasep_tlstream_msgbuf_acquire(
1786 TL_STREAM_TYPE_OBJ,
1787 msg_size, &flags);
1788 KBASE_DEBUG_ASSERT(buffer);
1789
1790 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
1791 pos = kbasep_tlstream_write_timestamp(buffer, pos);
1792 pos = kbasep_tlstream_write_bytes(
1793 buffer, pos, &atom, sizeof(atom));
1794 KBASE_DEBUG_ASSERT(msg_size == pos);
1795
1796 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_OBJ, flags);
1797 }
1798
__kbase_tlstream_tl_ret_ctx_lpu(void *context, void *lpu)1799 void __kbase_tlstream_tl_ret_ctx_lpu(void *context, void *lpu)
1800 {
1801 const u32 msg_id = KBASE_TL_RET_CTX_LPU;
1802 const size_t msg_size =
1803 sizeof(msg_id) + sizeof(u64) + sizeof(context) + sizeof(lpu);
1804 unsigned long flags;
1805 char *buffer;
1806 size_t pos = 0;
1807
1808 buffer = kbasep_tlstream_msgbuf_acquire(
1809 TL_STREAM_TYPE_OBJ,
1810 msg_size, &flags);
1811 KBASE_DEBUG_ASSERT(buffer);
1812
1813 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
1814 pos = kbasep_tlstream_write_timestamp(buffer, pos);
1815 pos = kbasep_tlstream_write_bytes(
1816 buffer, pos, &context, sizeof(context));
1817 pos = kbasep_tlstream_write_bytes(
1818 buffer, pos, &lpu, sizeof(lpu));
1819 KBASE_DEBUG_ASSERT(msg_size == pos);
1820
1821 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_OBJ, flags);
1822 }
1823
__kbase_tlstream_tl_ret_atom_ctx(void *atom, void *context)1824 void __kbase_tlstream_tl_ret_atom_ctx(void *atom, void *context)
1825 {
1826 const u32 msg_id = KBASE_TL_RET_ATOM_CTX;
1827 const size_t msg_size =
1828 sizeof(msg_id) + sizeof(u64) + sizeof(atom) + sizeof(context);
1829 unsigned long flags;
1830 char *buffer;
1831 size_t pos = 0;
1832
1833 buffer = kbasep_tlstream_msgbuf_acquire(
1834 TL_STREAM_TYPE_OBJ,
1835 msg_size, &flags);
1836 KBASE_DEBUG_ASSERT(buffer);
1837
1838 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
1839 pos = kbasep_tlstream_write_timestamp(buffer, pos);
1840 pos = kbasep_tlstream_write_bytes(
1841 buffer, pos, &atom, sizeof(atom));
1842 pos = kbasep_tlstream_write_bytes(
1843 buffer, pos, &context, sizeof(context));
1844 KBASE_DEBUG_ASSERT(msg_size == pos);
1845
1846 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_OBJ, flags);
1847 }
1848
__kbase_tlstream_tl_ret_atom_lpu( void *atom, void *lpu, const char *attrib_match_list)1849 void __kbase_tlstream_tl_ret_atom_lpu(
1850 void *atom, void *lpu, const char *attrib_match_list)
1851 {
1852 const u32 msg_id = KBASE_TL_RET_ATOM_LPU;
1853 const size_t msg_s0 = sizeof(u32) + sizeof(char) +
1854 strnlen(attrib_match_list, STRLEN_MAX);
1855 const size_t msg_size =
1856 sizeof(msg_id) + sizeof(u64) +
1857 sizeof(atom) + sizeof(lpu) + msg_s0;
1858 unsigned long flags;
1859 char *buffer;
1860 size_t pos = 0;
1861
1862 buffer = kbasep_tlstream_msgbuf_acquire(
1863 TL_STREAM_TYPE_OBJ,
1864 msg_size, &flags);
1865 KBASE_DEBUG_ASSERT(buffer);
1866
1867 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
1868 pos = kbasep_tlstream_write_timestamp(buffer, pos);
1869 pos = kbasep_tlstream_write_bytes(
1870 buffer, pos, &atom, sizeof(atom));
1871 pos = kbasep_tlstream_write_bytes(
1872 buffer, pos, &lpu, sizeof(lpu));
1873 pos = kbasep_tlstream_write_string(
1874 buffer, pos, attrib_match_list, msg_s0);
1875 KBASE_DEBUG_ASSERT(msg_size == pos);
1876
1877 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_OBJ, flags);
1878 }
1879
__kbase_tlstream_tl_nret_ctx_lpu(void *context, void *lpu)1880 void __kbase_tlstream_tl_nret_ctx_lpu(void *context, void *lpu)
1881 {
1882 const u32 msg_id = KBASE_TL_NRET_CTX_LPU;
1883 const size_t msg_size =
1884 sizeof(msg_id) + sizeof(u64) + sizeof(context) + sizeof(lpu);
1885 unsigned long flags;
1886 char *buffer;
1887 size_t pos = 0;
1888
1889 buffer = kbasep_tlstream_msgbuf_acquire(
1890 TL_STREAM_TYPE_OBJ,
1891 msg_size, &flags);
1892 KBASE_DEBUG_ASSERT(buffer);
1893
1894 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
1895 pos = kbasep_tlstream_write_timestamp(buffer, pos);
1896 pos = kbasep_tlstream_write_bytes(
1897 buffer, pos, &context, sizeof(context));
1898 pos = kbasep_tlstream_write_bytes(
1899 buffer, pos, &lpu, sizeof(lpu));
1900 KBASE_DEBUG_ASSERT(msg_size == pos);
1901
1902 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_OBJ, flags);
1903 }
1904
__kbase_tlstream_tl_nret_atom_ctx(void *atom, void *context)1905 void __kbase_tlstream_tl_nret_atom_ctx(void *atom, void *context)
1906 {
1907 const u32 msg_id = KBASE_TL_NRET_ATOM_CTX;
1908 const size_t msg_size =
1909 sizeof(msg_id) + sizeof(u64) + sizeof(atom) + sizeof(context);
1910 unsigned long flags;
1911 char *buffer;
1912 size_t pos = 0;
1913
1914 buffer = kbasep_tlstream_msgbuf_acquire(
1915 TL_STREAM_TYPE_OBJ,
1916 msg_size, &flags);
1917 KBASE_DEBUG_ASSERT(buffer);
1918
1919 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
1920 pos = kbasep_tlstream_write_timestamp(buffer, pos);
1921 pos = kbasep_tlstream_write_bytes(
1922 buffer, pos, &atom, sizeof(atom));
1923 pos = kbasep_tlstream_write_bytes(
1924 buffer, pos, &context, sizeof(context));
1925 KBASE_DEBUG_ASSERT(msg_size == pos);
1926
1927 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_OBJ, flags);
1928 }
1929
__kbase_tlstream_tl_dep_atom_atom(void *atom1, void *atom2)1930 void __kbase_tlstream_tl_dep_atom_atom(void *atom1, void *atom2)
1931 {
1932 const u32 msg_id = KBASE_TL_DEP_ATOM_ATOM;
1933 const size_t msg_size =
1934 sizeof(msg_id) + sizeof(u64) + sizeof(atom1) + sizeof(atom2);
1935 unsigned long flags;
1936 char *buffer;
1937 size_t pos = 0;
1938
1939 buffer = kbasep_tlstream_msgbuf_acquire(
1940 TL_STREAM_TYPE_OBJ,
1941 msg_size, &flags);
1942 KBASE_DEBUG_ASSERT(buffer);
1943
1944 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
1945 pos = kbasep_tlstream_write_timestamp(buffer, pos);
1946 pos = kbasep_tlstream_write_bytes(
1947 buffer, pos, &atom1, sizeof(atom1));
1948 pos = kbasep_tlstream_write_bytes(
1949 buffer, pos, &atom2, sizeof(atom2));
1950 KBASE_DEBUG_ASSERT(msg_size == pos);
1951
1952 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_OBJ, flags);
1953 }
1954
__kbase_tlstream_tl_ndep_atom_atom(void *atom1, void *atom2)1955 void __kbase_tlstream_tl_ndep_atom_atom(void *atom1, void *atom2)
1956 {
1957 const u32 msg_id = KBASE_TL_NDEP_ATOM_ATOM;
1958 const size_t msg_size =
1959 sizeof(msg_id) + sizeof(u64) + sizeof(atom1) + sizeof(atom2);
1960 unsigned long flags;
1961 char *buffer;
1962 size_t pos = 0;
1963
1964 buffer = kbasep_tlstream_msgbuf_acquire(
1965 TL_STREAM_TYPE_OBJ,
1966 msg_size, &flags);
1967 KBASE_DEBUG_ASSERT(buffer);
1968
1969 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
1970 pos = kbasep_tlstream_write_timestamp(buffer, pos);
1971 pos = kbasep_tlstream_write_bytes(
1972 buffer, pos, &atom1, sizeof(atom1));
1973 pos = kbasep_tlstream_write_bytes(
1974 buffer, pos, &atom2, sizeof(atom2));
1975 KBASE_DEBUG_ASSERT(msg_size == pos);
1976
1977 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_OBJ, flags);
1978 }
1979
__kbase_tlstream_tl_rdep_atom_atom(void *atom1, void *atom2)1980 void __kbase_tlstream_tl_rdep_atom_atom(void *atom1, void *atom2)
1981 {
1982 const u32 msg_id = KBASE_TL_RDEP_ATOM_ATOM;
1983 const size_t msg_size =
1984 sizeof(msg_id) + sizeof(u64) + sizeof(atom1) + sizeof(atom2);
1985 unsigned long flags;
1986 char *buffer;
1987 size_t pos = 0;
1988
1989 buffer = kbasep_tlstream_msgbuf_acquire(
1990 TL_STREAM_TYPE_OBJ,
1991 msg_size, &flags);
1992 KBASE_DEBUG_ASSERT(buffer);
1993
1994 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
1995 pos = kbasep_tlstream_write_timestamp(buffer, pos);
1996 pos = kbasep_tlstream_write_bytes(
1997 buffer, pos, &atom1, sizeof(atom1));
1998 pos = kbasep_tlstream_write_bytes(
1999 buffer, pos, &atom2, sizeof(atom2));
2000 KBASE_DEBUG_ASSERT(msg_size == pos);
2001
2002 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_OBJ, flags);
2003 }
2004
__kbase_tlstream_tl_nret_atom_lpu(void *atom, void *lpu)2005 void __kbase_tlstream_tl_nret_atom_lpu(void *atom, void *lpu)
2006 {
2007 const u32 msg_id = KBASE_TL_NRET_ATOM_LPU;
2008 const size_t msg_size =
2009 sizeof(msg_id) + sizeof(u64) + sizeof(atom) + sizeof(lpu);
2010 unsigned long flags;
2011 char *buffer;
2012 size_t pos = 0;
2013
2014 buffer = kbasep_tlstream_msgbuf_acquire(
2015 TL_STREAM_TYPE_OBJ,
2016 msg_size, &flags);
2017 KBASE_DEBUG_ASSERT(buffer);
2018
2019 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
2020 pos = kbasep_tlstream_write_timestamp(buffer, pos);
2021 pos = kbasep_tlstream_write_bytes(
2022 buffer, pos, &atom, sizeof(atom));
2023 pos = kbasep_tlstream_write_bytes(
2024 buffer, pos, &lpu, sizeof(lpu));
2025 KBASE_DEBUG_ASSERT(msg_size == pos);
2026
2027 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_OBJ, flags);
2028 }
2029
__kbase_tlstream_tl_ret_as_ctx(void *as, void *ctx)2030 void __kbase_tlstream_tl_ret_as_ctx(void *as, void *ctx)
2031 {
2032 const u32 msg_id = KBASE_TL_RET_AS_CTX;
2033 const size_t msg_size =
2034 sizeof(msg_id) + sizeof(u64) + sizeof(as) + sizeof(ctx);
2035 unsigned long flags;
2036 char *buffer;
2037 size_t pos = 0;
2038
2039 buffer = kbasep_tlstream_msgbuf_acquire(
2040 TL_STREAM_TYPE_OBJ,
2041 msg_size, &flags);
2042 KBASE_DEBUG_ASSERT(buffer);
2043
2044 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
2045 pos = kbasep_tlstream_write_timestamp(buffer, pos);
2046 pos = kbasep_tlstream_write_bytes(
2047 buffer, pos, &as, sizeof(as));
2048 pos = kbasep_tlstream_write_bytes(
2049 buffer, pos, &ctx, sizeof(ctx));
2050 KBASE_DEBUG_ASSERT(msg_size == pos);
2051
2052 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_OBJ, flags);
2053 }
2054
__kbase_tlstream_tl_nret_as_ctx(void *as, void *ctx)2055 void __kbase_tlstream_tl_nret_as_ctx(void *as, void *ctx)
2056 {
2057 const u32 msg_id = KBASE_TL_NRET_AS_CTX;
2058 const size_t msg_size =
2059 sizeof(msg_id) + sizeof(u64) + sizeof(as) + sizeof(ctx);
2060 unsigned long flags;
2061 char *buffer;
2062 size_t pos = 0;
2063
2064 buffer = kbasep_tlstream_msgbuf_acquire(
2065 TL_STREAM_TYPE_OBJ,
2066 msg_size, &flags);
2067 KBASE_DEBUG_ASSERT(buffer);
2068
2069 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
2070 pos = kbasep_tlstream_write_timestamp(buffer, pos);
2071 pos = kbasep_tlstream_write_bytes(
2072 buffer, pos, &as, sizeof(as));
2073 pos = kbasep_tlstream_write_bytes(
2074 buffer, pos, &ctx, sizeof(ctx));
2075 KBASE_DEBUG_ASSERT(msg_size == pos);
2076
2077 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_OBJ, flags);
2078 }
2079
__kbase_tlstream_tl_ret_atom_as(void *atom, void *as)2080 void __kbase_tlstream_tl_ret_atom_as(void *atom, void *as)
2081 {
2082 const u32 msg_id = KBASE_TL_RET_ATOM_AS;
2083 const size_t msg_size =
2084 sizeof(msg_id) + sizeof(u64) + sizeof(atom) + sizeof(as);
2085 unsigned long flags;
2086 char *buffer;
2087 size_t pos = 0;
2088
2089 buffer = kbasep_tlstream_msgbuf_acquire(
2090 TL_STREAM_TYPE_OBJ,
2091 msg_size, &flags);
2092 KBASE_DEBUG_ASSERT(buffer);
2093
2094 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
2095 pos = kbasep_tlstream_write_timestamp(buffer, pos);
2096 pos = kbasep_tlstream_write_bytes(
2097 buffer, pos, &atom, sizeof(atom));
2098 pos = kbasep_tlstream_write_bytes(
2099 buffer, pos, &as, sizeof(as));
2100 KBASE_DEBUG_ASSERT(msg_size == pos);
2101
2102 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_OBJ, flags);
2103 }
2104
__kbase_tlstream_tl_nret_atom_as(void *atom, void *as)2105 void __kbase_tlstream_tl_nret_atom_as(void *atom, void *as)
2106 {
2107 const u32 msg_id = KBASE_TL_NRET_ATOM_AS;
2108 const size_t msg_size =
2109 sizeof(msg_id) + sizeof(u64) + sizeof(atom) + sizeof(as);
2110 unsigned long flags;
2111 char *buffer;
2112 size_t pos = 0;
2113
2114 buffer = kbasep_tlstream_msgbuf_acquire(
2115 TL_STREAM_TYPE_OBJ,
2116 msg_size, &flags);
2117 KBASE_DEBUG_ASSERT(buffer);
2118
2119 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
2120 pos = kbasep_tlstream_write_timestamp(buffer, pos);
2121 pos = kbasep_tlstream_write_bytes(
2122 buffer, pos, &atom, sizeof(atom));
2123 pos = kbasep_tlstream_write_bytes(
2124 buffer, pos, &as, sizeof(as));
2125 KBASE_DEBUG_ASSERT(msg_size == pos);
2126
2127 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_OBJ, flags);
2128 }
2129
__kbase_tlstream_tl_attrib_atom_config( void *atom, u64 jd, u64 affinity, u32 config)2130 void __kbase_tlstream_tl_attrib_atom_config(
2131 void *atom, u64 jd, u64 affinity, u32 config)
2132 {
2133 const u32 msg_id = KBASE_TL_ATTRIB_ATOM_CONFIG;
2134 const size_t msg_size =
2135 sizeof(msg_id) + sizeof(u64) + sizeof(atom) +
2136 sizeof(jd) + sizeof(affinity) + sizeof(config);
2137 unsigned long flags;
2138 char *buffer;
2139 size_t pos = 0;
2140
2141 buffer = kbasep_tlstream_msgbuf_acquire(
2142 TL_STREAM_TYPE_OBJ,
2143 msg_size, &flags);
2144 KBASE_DEBUG_ASSERT(buffer);
2145
2146 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
2147 pos = kbasep_tlstream_write_timestamp(buffer, pos);
2148 pos = kbasep_tlstream_write_bytes(
2149 buffer, pos, &atom, sizeof(atom));
2150 pos = kbasep_tlstream_write_bytes(
2151 buffer, pos, &jd, sizeof(jd));
2152 pos = kbasep_tlstream_write_bytes(
2153 buffer, pos, &affinity, sizeof(affinity));
2154 pos = kbasep_tlstream_write_bytes(
2155 buffer, pos, &config, sizeof(config));
2156 KBASE_DEBUG_ASSERT(msg_size == pos);
2157
2158 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_OBJ, flags);
2159 }
2160
__kbase_tlstream_tl_attrib_atom_priority(void *atom, u32 prio)2161 void __kbase_tlstream_tl_attrib_atom_priority(void *atom, u32 prio)
2162 {
2163 const u32 msg_id = KBASE_TL_ATTRIB_ATOM_PRIORITY;
2164 const size_t msg_size =
2165 sizeof(msg_id) + sizeof(u64) + sizeof(atom) + sizeof(prio);
2166 unsigned long flags;
2167 char *buffer;
2168 size_t pos = 0;
2169
2170 buffer = kbasep_tlstream_msgbuf_acquire(
2171 TL_STREAM_TYPE_OBJ,
2172 msg_size, &flags);
2173 KBASE_DEBUG_ASSERT(buffer);
2174
2175 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
2176 pos = kbasep_tlstream_write_timestamp(buffer, pos);
2177 pos = kbasep_tlstream_write_bytes(
2178 buffer, pos, &atom, sizeof(atom));
2179 pos = kbasep_tlstream_write_bytes(
2180 buffer, pos, &prio, sizeof(prio));
2181 KBASE_DEBUG_ASSERT(msg_size == pos);
2182
2183 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_OBJ, flags);
2184 }
2185
__kbase_tlstream_tl_attrib_atom_state(void *atom, u32 state)2186 void __kbase_tlstream_tl_attrib_atom_state(void *atom, u32 state)
2187 {
2188 const u32 msg_id = KBASE_TL_ATTRIB_ATOM_STATE;
2189 const size_t msg_size =
2190 sizeof(msg_id) + sizeof(u64) + sizeof(atom) + sizeof(state);
2191 unsigned long flags;
2192 char *buffer;
2193 size_t pos = 0;
2194
2195 buffer = kbasep_tlstream_msgbuf_acquire(
2196 TL_STREAM_TYPE_OBJ,
2197 msg_size, &flags);
2198 KBASE_DEBUG_ASSERT(buffer);
2199
2200 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
2201 pos = kbasep_tlstream_write_timestamp(buffer, pos);
2202 pos = kbasep_tlstream_write_bytes(
2203 buffer, pos, &atom, sizeof(atom));
2204 pos = kbasep_tlstream_write_bytes(
2205 buffer, pos, &state, sizeof(state));
2206 KBASE_DEBUG_ASSERT(msg_size == pos);
2207
2208 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_OBJ, flags);
2209 }
2210
__kbase_tlstream_tl_attrib_atom_priority_change(void *atom)2211 void __kbase_tlstream_tl_attrib_atom_priority_change(void *atom)
2212 {
2213 const u32 msg_id = KBASE_TL_ATTRIB_ATOM_PRIORITY_CHANGE;
2214 const size_t msg_size =
2215 sizeof(msg_id) + sizeof(u64) + sizeof(atom);
2216 unsigned long flags;
2217 char *buffer;
2218 size_t pos = 0;
2219
2220 buffer = kbasep_tlstream_msgbuf_acquire(
2221 TL_STREAM_TYPE_OBJ,
2222 msg_size, &flags);
2223 KBASE_DEBUG_ASSERT(buffer);
2224
2225 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
2226 pos = kbasep_tlstream_write_timestamp(buffer, pos);
2227 pos = kbasep_tlstream_write_bytes(
2228 buffer, pos, &atom, sizeof(atom));
2229 KBASE_DEBUG_ASSERT(msg_size == pos);
2230
2231 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_OBJ, flags);
2232 }
2233
__kbase_tlstream_tl_attrib_atom_jit( void *atom, u64 edit_addr, u64 new_addr)2234 void __kbase_tlstream_tl_attrib_atom_jit(
2235 void *atom, u64 edit_addr, u64 new_addr)
2236 {
2237 const u32 msg_id = KBASE_TL_ATTRIB_ATOM_JIT;
2238 const size_t msg_size =
2239 sizeof(msg_id) + sizeof(u64) + sizeof(atom)
2240 + sizeof(edit_addr) + sizeof(new_addr);
2241 unsigned long flags;
2242 char *buffer;
2243 size_t pos = 0;
2244
2245 buffer = kbasep_tlstream_msgbuf_acquire(
2246 TL_STREAM_TYPE_OBJ,
2247 msg_size, &flags);
2248 KBASE_DEBUG_ASSERT(buffer);
2249
2250 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
2251 pos = kbasep_tlstream_write_timestamp(buffer, pos);
2252 pos = kbasep_tlstream_write_bytes(
2253 buffer, pos, &atom, sizeof(atom));
2254 pos = kbasep_tlstream_write_bytes(
2255 buffer, pos, &edit_addr, sizeof(edit_addr));
2256 pos = kbasep_tlstream_write_bytes(
2257 buffer, pos, &new_addr, sizeof(new_addr));
2258 KBASE_DEBUG_ASSERT(msg_size == pos);
2259
2260 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_OBJ, flags);
2261 }
2262
__kbase_tlstream_tl_attrib_as_config( void *as, u64 transtab, u64 memattr, u64 transcfg)2263 void __kbase_tlstream_tl_attrib_as_config(
2264 void *as, u64 transtab, u64 memattr, u64 transcfg)
2265 {
2266 const u32 msg_id = KBASE_TL_ATTRIB_AS_CONFIG;
2267 const size_t msg_size =
2268 sizeof(msg_id) + sizeof(u64) + sizeof(as) +
2269 sizeof(transtab) + sizeof(memattr) + sizeof(transcfg);
2270 unsigned long flags;
2271 char *buffer;
2272 size_t pos = 0;
2273
2274 buffer = kbasep_tlstream_msgbuf_acquire(
2275 TL_STREAM_TYPE_OBJ,
2276 msg_size, &flags);
2277 KBASE_DEBUG_ASSERT(buffer);
2278
2279 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
2280 pos = kbasep_tlstream_write_timestamp(buffer, pos);
2281 pos = kbasep_tlstream_write_bytes(
2282 buffer, pos, &as, sizeof(as));
2283 pos = kbasep_tlstream_write_bytes(
2284 buffer, pos, &transtab, sizeof(transtab));
2285 pos = kbasep_tlstream_write_bytes(
2286 buffer, pos, &memattr, sizeof(memattr));
2287 pos = kbasep_tlstream_write_bytes(
2288 buffer, pos, &transcfg, sizeof(transcfg));
2289 KBASE_DEBUG_ASSERT(msg_size == pos);
2290
2291 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_OBJ, flags);
2292 }
2293
__kbase_tlstream_tl_event_lpu_softstop(void *lpu)2294 void __kbase_tlstream_tl_event_lpu_softstop(void *lpu)
2295 {
2296 const u32 msg_id = KBASE_TL_EVENT_LPU_SOFTSTOP;
2297 const size_t msg_size =
2298 sizeof(msg_id) + sizeof(u64) + sizeof(lpu);
2299 unsigned long flags;
2300 char *buffer;
2301 size_t pos = 0;
2302
2303 buffer = kbasep_tlstream_msgbuf_acquire(
2304 TL_STREAM_TYPE_OBJ,
2305 msg_size, &flags);
2306 KBASE_DEBUG_ASSERT(buffer);
2307
2308 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
2309 pos = kbasep_tlstream_write_timestamp(buffer, pos);
2310 pos = kbasep_tlstream_write_bytes(
2311 buffer, pos, &lpu, sizeof(lpu));
2312 KBASE_DEBUG_ASSERT(msg_size == pos);
2313
2314 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_OBJ, flags);
2315 }
2316
__kbase_tlstream_tl_event_atom_softstop_ex(void *atom)2317 void __kbase_tlstream_tl_event_atom_softstop_ex(void *atom)
2318 {
2319 const u32 msg_id = KBASE_TL_EVENT_ATOM_SOFTSTOP_EX;
2320 const size_t msg_size =
2321 sizeof(msg_id) + sizeof(u64) + sizeof(atom);
2322 unsigned long flags;
2323 char *buffer;
2324 size_t pos = 0;
2325
2326 buffer = kbasep_tlstream_msgbuf_acquire(
2327 TL_STREAM_TYPE_OBJ,
2328 msg_size, &flags);
2329 KBASE_DEBUG_ASSERT(buffer);
2330
2331 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
2332 pos = kbasep_tlstream_write_timestamp(buffer, pos);
2333 pos = kbasep_tlstream_write_bytes(
2334 buffer, pos, &atom, sizeof(atom));
2335 KBASE_DEBUG_ASSERT(msg_size == pos);
2336
2337 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_OBJ, flags);
2338 }
2339
__kbase_tlstream_tl_event_atom_softstop_issue(void *atom)2340 void __kbase_tlstream_tl_event_atom_softstop_issue(void *atom)
2341 {
2342 const u32 msg_id = KBASE_TL_EVENT_ATOM_SOFTSTOP_ISSUE;
2343 const size_t msg_size =
2344 sizeof(msg_id) + sizeof(u64) + sizeof(atom);
2345 unsigned long flags;
2346 char *buffer;
2347 size_t pos = 0;
2348
2349 buffer = kbasep_tlstream_msgbuf_acquire(
2350 TL_STREAM_TYPE_OBJ,
2351 msg_size, &flags);
2352 KBASE_DEBUG_ASSERT(buffer);
2353
2354 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
2355 pos = kbasep_tlstream_write_timestamp(buffer, pos);
2356 pos = kbasep_tlstream_write_bytes(
2357 buffer, pos, &atom, sizeof(atom));
2358 KBASE_DEBUG_ASSERT(msg_size == pos);
2359
2360 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_OBJ, flags);
2361 }
2362
__kbase_tlstream_jd_gpu_soft_reset(void *gpu)2363 void __kbase_tlstream_jd_gpu_soft_reset(void *gpu)
2364 {
2365 const u32 msg_id = KBASE_JD_GPU_SOFT_RESET;
2366 const size_t msg_size =
2367 sizeof(msg_id) + sizeof(u64) + sizeof(gpu);
2368 unsigned long flags;
2369 char *buffer;
2370 size_t pos = 0;
2371
2372 buffer = kbasep_tlstream_msgbuf_acquire(
2373 TL_STREAM_TYPE_OBJ,
2374 msg_size, &flags);
2375 KBASE_DEBUG_ASSERT(buffer);
2376
2377 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
2378 pos = kbasep_tlstream_write_timestamp(buffer, pos);
2379 pos = kbasep_tlstream_write_bytes(
2380 buffer, pos, &gpu, sizeof(gpu));
2381 KBASE_DEBUG_ASSERT(msg_size == pos);
2382
2383 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_OBJ, flags);
2384 }
2385
2386 /*****************************************************************************/
2387
__kbase_tlstream_aux_pm_state(u32 core_type, u64 state)2388 void __kbase_tlstream_aux_pm_state(u32 core_type, u64 state)
2389 {
2390 const u32 msg_id = KBASE_AUX_PM_STATE;
2391 const size_t msg_size =
2392 sizeof(msg_id) + sizeof(u64) + sizeof(core_type) +
2393 sizeof(state);
2394 unsigned long flags;
2395 char *buffer;
2396 size_t pos = 0;
2397
2398 buffer = kbasep_tlstream_msgbuf_acquire(
2399 TL_STREAM_TYPE_AUX,
2400 msg_size, &flags);
2401 KBASE_DEBUG_ASSERT(buffer);
2402
2403 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
2404 pos = kbasep_tlstream_write_timestamp(buffer, pos);
2405 pos = kbasep_tlstream_write_bytes(
2406 buffer, pos, &core_type, sizeof(core_type));
2407 pos = kbasep_tlstream_write_bytes(buffer, pos, &state, sizeof(state));
2408 KBASE_DEBUG_ASSERT(msg_size == pos);
2409
2410 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_AUX, flags);
2411 }
2412
__kbase_tlstream_aux_pagefault(u32 ctx_nr, u64 page_count_change)2413 void __kbase_tlstream_aux_pagefault(u32 ctx_nr, u64 page_count_change)
2414 {
2415 const u32 msg_id = KBASE_AUX_PAGEFAULT;
2416 const size_t msg_size =
2417 sizeof(msg_id) + sizeof(u64) + sizeof(ctx_nr) +
2418 sizeof(page_count_change);
2419 unsigned long flags;
2420 char *buffer;
2421 size_t pos = 0;
2422
2423 buffer = kbasep_tlstream_msgbuf_acquire(
2424 TL_STREAM_TYPE_AUX, msg_size, &flags);
2425 KBASE_DEBUG_ASSERT(buffer);
2426
2427 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
2428 pos = kbasep_tlstream_write_timestamp(buffer, pos);
2429 pos = kbasep_tlstream_write_bytes(buffer, pos, &ctx_nr, sizeof(ctx_nr));
2430 pos = kbasep_tlstream_write_bytes(
2431 buffer, pos,
2432 &page_count_change, sizeof(page_count_change));
2433 KBASE_DEBUG_ASSERT(msg_size == pos);
2434
2435 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_AUX, flags);
2436 }
2437
__kbase_tlstream_aux_pagesalloc(u32 ctx_nr, u64 page_count)2438 void __kbase_tlstream_aux_pagesalloc(u32 ctx_nr, u64 page_count)
2439 {
2440 const u32 msg_id = KBASE_AUX_PAGESALLOC;
2441 const size_t msg_size =
2442 sizeof(msg_id) + sizeof(u64) + sizeof(ctx_nr) +
2443 sizeof(page_count);
2444 unsigned long flags;
2445 char *buffer;
2446 size_t pos = 0;
2447
2448 buffer = kbasep_tlstream_msgbuf_acquire(
2449 TL_STREAM_TYPE_AUX, msg_size, &flags);
2450 KBASE_DEBUG_ASSERT(buffer);
2451
2452 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
2453 pos = kbasep_tlstream_write_timestamp(buffer, pos);
2454 pos = kbasep_tlstream_write_bytes(buffer, pos, &ctx_nr, sizeof(ctx_nr));
2455 pos = kbasep_tlstream_write_bytes(
2456 buffer, pos, &page_count, sizeof(page_count));
2457 KBASE_DEBUG_ASSERT(msg_size == pos);
2458
2459 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_AUX, flags);
2460 }
2461
__kbase_tlstream_aux_devfreq_target(u64 target_freq)2462 void __kbase_tlstream_aux_devfreq_target(u64 target_freq)
2463 {
2464 const u32 msg_id = KBASE_AUX_DEVFREQ_TARGET;
2465 const size_t msg_size =
2466 sizeof(msg_id) + sizeof(u64) + sizeof(target_freq);
2467 unsigned long flags;
2468 char *buffer;
2469 size_t pos = 0;
2470
2471 buffer = kbasep_tlstream_msgbuf_acquire(
2472 TL_STREAM_TYPE_AUX, msg_size, &flags);
2473 KBASE_DEBUG_ASSERT(buffer);
2474
2475 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
2476 pos = kbasep_tlstream_write_timestamp(buffer, pos);
2477 pos = kbasep_tlstream_write_bytes(
2478 buffer, pos, &target_freq, sizeof(target_freq));
2479 KBASE_DEBUG_ASSERT(msg_size == pos);
2480
2481 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_AUX, flags);
2482 }
2483
__kbase_tlstream_aux_protected_enter_start(void *gpu)2484 void __kbase_tlstream_aux_protected_enter_start(void *gpu)
2485 {
2486 const u32 msg_id = KBASE_AUX_PROTECTED_ENTER_START;
2487 const size_t msg_size =
2488 sizeof(msg_id) + sizeof(u64) + sizeof(gpu);
2489 unsigned long flags;
2490 char *buffer;
2491 size_t pos = 0;
2492
2493 buffer = kbasep_tlstream_msgbuf_acquire(
2494 TL_STREAM_TYPE_AUX,
2495 msg_size, &flags);
2496 KBASE_DEBUG_ASSERT(buffer);
2497
2498 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
2499 pos = kbasep_tlstream_write_timestamp(buffer, pos);
2500 pos = kbasep_tlstream_write_bytes(
2501 buffer, pos, &gpu, sizeof(gpu));
2502 KBASE_DEBUG_ASSERT(msg_size == pos);
2503
2504 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_AUX, flags);
2505 }
__kbase_tlstream_aux_protected_enter_end(void *gpu)2506 void __kbase_tlstream_aux_protected_enter_end(void *gpu)
2507 {
2508 const u32 msg_id = KBASE_AUX_PROTECTED_ENTER_END;
2509 const size_t msg_size =
2510 sizeof(msg_id) + sizeof(u64) + sizeof(gpu);
2511 unsigned long flags;
2512 char *buffer;
2513 size_t pos = 0;
2514
2515 buffer = kbasep_tlstream_msgbuf_acquire(
2516 TL_STREAM_TYPE_AUX,
2517 msg_size, &flags);
2518 KBASE_DEBUG_ASSERT(buffer);
2519
2520 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
2521 pos = kbasep_tlstream_write_timestamp(buffer, pos);
2522 pos = kbasep_tlstream_write_bytes(
2523 buffer, pos, &gpu, sizeof(gpu));
2524 KBASE_DEBUG_ASSERT(msg_size == pos);
2525
2526 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_AUX, flags);
2527 }
2528
__kbase_tlstream_aux_protected_leave_start(void *gpu)2529 void __kbase_tlstream_aux_protected_leave_start(void *gpu)
2530 {
2531 const u32 msg_id = KBASE_AUX_PROTECTED_LEAVE_START;
2532 const size_t msg_size =
2533 sizeof(msg_id) + sizeof(u64) + sizeof(gpu);
2534 unsigned long flags;
2535 char *buffer;
2536 size_t pos = 0;
2537
2538 buffer = kbasep_tlstream_msgbuf_acquire(
2539 TL_STREAM_TYPE_AUX,
2540 msg_size, &flags);
2541 KBASE_DEBUG_ASSERT(buffer);
2542
2543 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
2544 pos = kbasep_tlstream_write_timestamp(buffer, pos);
2545 pos = kbasep_tlstream_write_bytes(
2546 buffer, pos, &gpu, sizeof(gpu));
2547 KBASE_DEBUG_ASSERT(msg_size == pos);
2548
2549 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_AUX, flags);
2550 }
__kbase_tlstream_aux_protected_leave_end(void *gpu)2551 void __kbase_tlstream_aux_protected_leave_end(void *gpu)
2552 {
2553 const u32 msg_id = KBASE_AUX_PROTECTED_LEAVE_END;
2554 const size_t msg_size =
2555 sizeof(msg_id) + sizeof(u64) + sizeof(gpu);
2556 unsigned long flags;
2557 char *buffer;
2558 size_t pos = 0;
2559
2560 buffer = kbasep_tlstream_msgbuf_acquire(
2561 TL_STREAM_TYPE_AUX,
2562 msg_size, &flags);
2563 KBASE_DEBUG_ASSERT(buffer);
2564
2565 pos = kbasep_tlstream_write_bytes(buffer, pos, &msg_id, sizeof(msg_id));
2566 pos = kbasep_tlstream_write_timestamp(buffer, pos);
2567 pos = kbasep_tlstream_write_bytes(
2568 buffer, pos, &gpu, sizeof(gpu));
2569 KBASE_DEBUG_ASSERT(msg_size == pos);
2570
2571 kbasep_tlstream_msgbuf_release(TL_STREAM_TYPE_AUX, flags);
2572 }
2573