1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21#include <stdio.h>
22#include <stdlib.h>
23#include <string.h>
24
25#include "kbuffer.h"
26
27#define MISSING_EVENTS (1 << 31)
28#define MISSING_STORED (1 << 30)
29
30#define COMMIT_MASK ((1 << 27) - 1)
31
32enum {
33 KBUFFER_FL_HOST_BIG_ENDIAN = (1<<0),
34 KBUFFER_FL_BIG_ENDIAN = (1<<1),
35 KBUFFER_FL_LONG_8 = (1<<2),
36 KBUFFER_FL_OLD_FORMAT = (1<<3),
37};
38
39#define ENDIAN_MASK (KBUFFER_FL_HOST_BIG_ENDIAN | KBUFFER_FL_BIG_ENDIAN)
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58struct kbuffer {
59 unsigned long long timestamp;
60 long long lost_events;
61 unsigned long flags;
62 void *subbuffer;
63 void *data;
64 unsigned int index;
65 unsigned int curr;
66 unsigned int next;
67 unsigned int size;
68 unsigned int start;
69
70 unsigned int (*read_4)(void *ptr);
71 unsigned long long (*read_8)(void *ptr);
72 unsigned long long (*read_long)(struct kbuffer *kbuf, void *ptr);
73 int (*next_event)(struct kbuffer *kbuf);
74};
75
76static void *zmalloc(size_t size)
77{
78 return calloc(1, size);
79}
80
81static int host_is_bigendian(void)
82{
83 unsigned char str[] = { 0x1, 0x2, 0x3, 0x4 };
84 unsigned int *ptr;
85
86 ptr = (unsigned int *)str;
87 return *ptr == 0x01020304;
88}
89
90static int do_swap(struct kbuffer *kbuf)
91{
92 return ((kbuf->flags & KBUFFER_FL_HOST_BIG_ENDIAN) + kbuf->flags) &
93 ENDIAN_MASK;
94}
95
96static unsigned long long __read_8(void *ptr)
97{
98 unsigned long long data = *(unsigned long long *)ptr;
99
100 return data;
101}
102
103static unsigned long long __read_8_sw(void *ptr)
104{
105 unsigned long long data = *(unsigned long long *)ptr;
106 unsigned long long swap;
107
108 swap = ((data & 0xffULL) << 56) |
109 ((data & (0xffULL << 8)) << 40) |
110 ((data & (0xffULL << 16)) << 24) |
111 ((data & (0xffULL << 24)) << 8) |
112 ((data & (0xffULL << 32)) >> 8) |
113 ((data & (0xffULL << 40)) >> 24) |
114 ((data & (0xffULL << 48)) >> 40) |
115 ((data & (0xffULL << 56)) >> 56);
116
117 return swap;
118}
119
120static unsigned int __read_4(void *ptr)
121{
122 unsigned int data = *(unsigned int *)ptr;
123
124 return data;
125}
126
127static unsigned int __read_4_sw(void *ptr)
128{
129 unsigned int data = *(unsigned int *)ptr;
130 unsigned int swap;
131
132 swap = ((data & 0xffULL) << 24) |
133 ((data & (0xffULL << 8)) << 8) |
134 ((data & (0xffULL << 16)) >> 8) |
135 ((data & (0xffULL << 24)) >> 24);
136
137 return swap;
138}
139
140static unsigned long long read_8(struct kbuffer *kbuf, void *ptr)
141{
142 return kbuf->read_8(ptr);
143}
144
145static unsigned int read_4(struct kbuffer *kbuf, void *ptr)
146{
147 return kbuf->read_4(ptr);
148}
149
150static unsigned long long __read_long_8(struct kbuffer *kbuf, void *ptr)
151{
152 return kbuf->read_8(ptr);
153}
154
155static unsigned long long __read_long_4(struct kbuffer *kbuf, void *ptr)
156{
157 return kbuf->read_4(ptr);
158}
159
160static unsigned long long read_long(struct kbuffer *kbuf, void *ptr)
161{
162 return kbuf->read_long(kbuf, ptr);
163}
164
165static int calc_index(struct kbuffer *kbuf, void *ptr)
166{
167 return (unsigned long)ptr - (unsigned long)kbuf->data;
168}
169
170static int __next_event(struct kbuffer *kbuf);
171
172
173
174
175
176
177
178
179struct kbuffer *
180kbuffer_alloc(enum kbuffer_long_size size, enum kbuffer_endian endian)
181{
182 struct kbuffer *kbuf;
183 int flags = 0;
184
185 switch (size) {
186 case KBUFFER_LSIZE_4:
187 break;
188 case KBUFFER_LSIZE_8:
189 flags |= KBUFFER_FL_LONG_8;
190 break;
191 default:
192 return NULL;
193 }
194
195 switch (endian) {
196 case KBUFFER_ENDIAN_LITTLE:
197 break;
198 case KBUFFER_ENDIAN_BIG:
199 flags |= KBUFFER_FL_BIG_ENDIAN;
200 break;
201 default:
202 return NULL;
203 }
204
205 kbuf = zmalloc(sizeof(*kbuf));
206 if (!kbuf)
207 return NULL;
208
209 kbuf->flags = flags;
210
211 if (host_is_bigendian())
212 kbuf->flags |= KBUFFER_FL_HOST_BIG_ENDIAN;
213
214 if (do_swap(kbuf)) {
215 kbuf->read_8 = __read_8_sw;
216 kbuf->read_4 = __read_4_sw;
217 } else {
218 kbuf->read_8 = __read_8;
219 kbuf->read_4 = __read_4;
220 }
221
222 if (kbuf->flags & KBUFFER_FL_LONG_8)
223 kbuf->read_long = __read_long_8;
224 else
225 kbuf->read_long = __read_long_4;
226
227
228 kbuf->next_event = __next_event;
229
230 return kbuf;
231}
232
233
234
235
236
237
238void kbuffer_free(struct kbuffer *kbuf)
239{
240 free(kbuf);
241}
242
243static unsigned int type4host(struct kbuffer *kbuf,
244 unsigned int type_len_ts)
245{
246 if (kbuf->flags & KBUFFER_FL_BIG_ENDIAN)
247 return (type_len_ts >> 29) & 3;
248 else
249 return type_len_ts & 3;
250}
251
252static unsigned int len4host(struct kbuffer *kbuf,
253 unsigned int type_len_ts)
254{
255 if (kbuf->flags & KBUFFER_FL_BIG_ENDIAN)
256 return (type_len_ts >> 27) & 7;
257 else
258 return (type_len_ts >> 2) & 7;
259}
260
261static unsigned int type_len4host(struct kbuffer *kbuf,
262 unsigned int type_len_ts)
263{
264 if (kbuf->flags & KBUFFER_FL_BIG_ENDIAN)
265 return (type_len_ts >> 27) & ((1 << 5) - 1);
266 else
267 return type_len_ts & ((1 << 5) - 1);
268}
269
270static unsigned int ts4host(struct kbuffer *kbuf,
271 unsigned int type_len_ts)
272{
273 if (kbuf->flags & KBUFFER_FL_BIG_ENDIAN)
274 return type_len_ts & ((1 << 27) - 1);
275 else
276 return type_len_ts >> 5;
277}
278
279
280
281
282
283enum old_ring_buffer_type {
284 OLD_RINGBUF_TYPE_PADDING,
285 OLD_RINGBUF_TYPE_TIME_EXTEND,
286 OLD_RINGBUF_TYPE_TIME_STAMP,
287 OLD_RINGBUF_TYPE_DATA,
288};
289
290static unsigned int old_update_pointers(struct kbuffer *kbuf)
291{
292 unsigned long long extend;
293 unsigned int type_len_ts;
294 unsigned int type;
295 unsigned int len;
296 unsigned int delta;
297 unsigned int length;
298 void *ptr = kbuf->data + kbuf->curr;
299
300 type_len_ts = read_4(kbuf, ptr);
301 ptr += 4;
302
303 type = type4host(kbuf, type_len_ts);
304 len = len4host(kbuf, type_len_ts);
305 delta = ts4host(kbuf, type_len_ts);
306
307 switch (type) {
308 case OLD_RINGBUF_TYPE_PADDING:
309 kbuf->next = kbuf->size;
310 return 0;
311
312 case OLD_RINGBUF_TYPE_TIME_EXTEND:
313 extend = read_4(kbuf, ptr);
314 extend <<= TS_SHIFT;
315 extend += delta;
316 delta = extend;
317 ptr += 4;
318 break;
319
320 case OLD_RINGBUF_TYPE_TIME_STAMP:
321
322 kbuf->curr = kbuf->size;
323 kbuf->next = kbuf->size;
324 kbuf->index = kbuf->size;
325 return -1;
326 default:
327 if (len)
328 length = len * 4;
329 else {
330 length = read_4(kbuf, ptr);
331 length -= 4;
332 ptr += 4;
333 }
334 break;
335 }
336
337 kbuf->timestamp += delta;
338 kbuf->index = calc_index(kbuf, ptr);
339 kbuf->next = kbuf->index + length;
340
341 return type;
342}
343
344static int __old_next_event(struct kbuffer *kbuf)
345{
346 int type;
347
348 do {
349 kbuf->curr = kbuf->next;
350 if (kbuf->next >= kbuf->size)
351 return -1;
352 type = old_update_pointers(kbuf);
353 } while (type == OLD_RINGBUF_TYPE_TIME_EXTEND || type == OLD_RINGBUF_TYPE_PADDING);
354
355 return 0;
356}
357
358static unsigned int
359translate_data(struct kbuffer *kbuf, void *data, void **rptr,
360 unsigned long long *delta, int *length)
361{
362 unsigned long long extend;
363 unsigned int type_len_ts;
364 unsigned int type_len;
365
366 type_len_ts = read_4(kbuf, data);
367 data += 4;
368
369 type_len = type_len4host(kbuf, type_len_ts);
370 *delta = ts4host(kbuf, type_len_ts);
371
372 switch (type_len) {
373 case KBUFFER_TYPE_PADDING:
374 *length = read_4(kbuf, data);
375 break;
376
377 case KBUFFER_TYPE_TIME_EXTEND:
378 extend = read_4(kbuf, data);
379 data += 4;
380 extend <<= TS_SHIFT;
381 extend += *delta;
382 *delta = extend;
383 *length = 0;
384 break;
385
386 case KBUFFER_TYPE_TIME_STAMP:
387 data += 12;
388 *length = 0;
389 break;
390 case 0:
391 *length = read_4(kbuf, data) - 4;
392 *length = (*length + 3) & ~3;
393 data += 4;
394 break;
395 default:
396 *length = type_len * 4;
397 break;
398 }
399
400 *rptr = data;
401
402 return type_len;
403}
404
405static unsigned int update_pointers(struct kbuffer *kbuf)
406{
407 unsigned long long delta;
408 unsigned int type_len;
409 int length;
410 void *ptr = kbuf->data + kbuf->curr;
411
412 type_len = translate_data(kbuf, ptr, &ptr, &delta, &length);
413
414 kbuf->timestamp += delta;
415 kbuf->index = calc_index(kbuf, ptr);
416 kbuf->next = kbuf->index + length;
417
418 return type_len;
419}
420
421
422
423
424
425
426
427
428
429
430
431void *kbuffer_translate_data(int swap, void *data, unsigned int *size)
432{
433 unsigned long long delta;
434 struct kbuffer kbuf;
435 int type_len;
436 int length;
437 void *ptr;
438
439 if (swap) {
440 kbuf.read_8 = __read_8_sw;
441 kbuf.read_4 = __read_4_sw;
442 kbuf.flags = host_is_bigendian() ? 0 : KBUFFER_FL_BIG_ENDIAN;
443 } else {
444 kbuf.read_8 = __read_8;
445 kbuf.read_4 = __read_4;
446 kbuf.flags = host_is_bigendian() ? KBUFFER_FL_BIG_ENDIAN: 0;
447 }
448
449 type_len = translate_data(&kbuf, data, &ptr, &delta, &length);
450 switch (type_len) {
451 case KBUFFER_TYPE_PADDING:
452 case KBUFFER_TYPE_TIME_EXTEND:
453 case KBUFFER_TYPE_TIME_STAMP:
454 return NULL;
455 };
456
457 *size = length;
458
459 return ptr;
460}
461
462static int __next_event(struct kbuffer *kbuf)
463{
464 int type;
465
466 do {
467 kbuf->curr = kbuf->next;
468 if (kbuf->next >= kbuf->size)
469 return -1;
470 type = update_pointers(kbuf);
471 } while (type == KBUFFER_TYPE_TIME_EXTEND || type == KBUFFER_TYPE_PADDING);
472
473 return 0;
474}
475
476static int next_event(struct kbuffer *kbuf)
477{
478 return kbuf->next_event(kbuf);
479}
480
481
482
483
484
485
486
487
488
489
490
491
492
493void *kbuffer_next_event(struct kbuffer *kbuf, unsigned long long *ts)
494{
495 int ret;
496
497 if (!kbuf || !kbuf->subbuffer)
498 return NULL;
499
500 ret = next_event(kbuf);
501 if (ret < 0)
502 return NULL;
503
504 if (ts)
505 *ts = kbuf->timestamp;
506
507 return kbuf->data + kbuf->index;
508}
509
510
511
512
513
514
515
516
517
518
519
520
521int kbuffer_load_subbuffer(struct kbuffer *kbuf, void *subbuffer)
522{
523 unsigned long long flags;
524 void *ptr = subbuffer;
525
526 if (!kbuf || !subbuffer)
527 return -1;
528
529 kbuf->subbuffer = subbuffer;
530
531 kbuf->timestamp = read_8(kbuf, ptr);
532 ptr += 8;
533
534 kbuf->curr = 0;
535
536 if (kbuf->flags & KBUFFER_FL_LONG_8)
537 kbuf->start = 16;
538 else
539 kbuf->start = 12;
540
541 kbuf->data = subbuffer + kbuf->start;
542
543 flags = read_long(kbuf, ptr);
544 kbuf->size = (unsigned int)flags & COMMIT_MASK;
545
546 if (flags & MISSING_EVENTS) {
547 if (flags & MISSING_STORED) {
548 ptr = kbuf->data + kbuf->size;
549 kbuf->lost_events = read_long(kbuf, ptr);
550 } else
551 kbuf->lost_events = -1;
552 } else
553 kbuf->lost_events = 0;
554
555 kbuf->index = 0;
556 kbuf->next = 0;
557
558 next_event(kbuf);
559
560 return 0;
561}
562
563
564
565
566
567
568
569
570
571void *kbuffer_read_event(struct kbuffer *kbuf, unsigned long long *ts)
572{
573 if (!kbuf || !kbuf->subbuffer)
574 return NULL;
575
576 if (kbuf->curr >= kbuf->size)
577 return NULL;
578
579 if (ts)
580 *ts = kbuf->timestamp;
581 return kbuf->data + kbuf->index;
582}
583
584
585
586
587
588
589
590unsigned long long kbuffer_timestamp(struct kbuffer *kbuf)
591{
592 return kbuf->timestamp;
593}
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613void *kbuffer_read_at_offset(struct kbuffer *kbuf, int offset,
614 unsigned long long *ts)
615{
616 void *data;
617
618 if (offset < kbuf->start)
619 offset = 0;
620 else
621 offset -= kbuf->start;
622
623
624 kbuffer_load_subbuffer(kbuf, kbuf->subbuffer);
625 data = kbuffer_read_event(kbuf, ts);
626
627 while (kbuf->curr < offset) {
628 data = kbuffer_next_event(kbuf, ts);
629 if (!data)
630 break;
631 }
632
633 return data;
634}
635
636
637
638
639
640
641
642
643
644int kbuffer_subbuffer_size(struct kbuffer *kbuf)
645{
646 return kbuf->size;
647}
648
649
650
651
652
653
654
655
656
657
658
659int kbuffer_curr_index(struct kbuffer *kbuf)
660{
661 return kbuf->curr;
662}
663
664
665
666
667
668
669
670
671int kbuffer_curr_offset(struct kbuffer *kbuf)
672{
673 return kbuf->curr + kbuf->start;
674}
675
676
677
678
679
680
681
682
683int kbuffer_event_size(struct kbuffer *kbuf)
684{
685 return kbuf->next - kbuf->index;
686}
687
688
689
690
691
692
693
694
695int kbuffer_curr_size(struct kbuffer *kbuf)
696{
697 return kbuf->next - kbuf->curr;
698}
699
700
701
702
703
704
705
706
707
708
709int kbuffer_missed_events(struct kbuffer *kbuf)
710{
711
712 if (kbuf->curr)
713 return 0;
714
715 return kbuf->lost_events;
716}
717
718
719
720
721
722
723
724
725
726
727void kbuffer_set_old_format(struct kbuffer *kbuf)
728{
729 kbuf->flags |= KBUFFER_FL_OLD_FORMAT;
730
731 kbuf->next_event = __old_next_event;
732}
733
734
735
736
737
738
739
740int kbuffer_start_of_data(struct kbuffer *kbuf)
741{
742 return kbuf->start;
743}
744