OSCL-LXR linux-6.0.1/​tools/​lib/​traceevent/​kbuffer-parse.c	Source navigation Diff markup Identifier search General search
	Version: linux-6.0.1 spark-3.0.0 hadoop-3.2.0-src hadoop-3.3.0-src spark-2.4.7 linux-4.15.13 hadoop-2.7.4-src Revert   Change

 // SPDX-License-Identifier: LGPL-2.1
 /*
  * Copyright (C) 2009, 2010 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
  *
  */
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "kbuffer.h"
 
 #define MISSING_EVENTS (1UL << 31)
 #define MISSING_STORED (1UL << 30)
 
 #define COMMIT_MASK ((1 << 27) - 1)
 
 enum {
     KBUFFER_FL_HOST_BIG_ENDIAN  = (1<<0),
     KBUFFER_FL_BIG_ENDIAN       = (1<<1),
     KBUFFER_FL_LONG_8       = (1<<2),
     KBUFFER_FL_OLD_FORMAT       = (1<<3),
 };
 
 #define ENDIAN_MASK (KBUFFER_FL_HOST_BIG_ENDIAN | KBUFFER_FL_BIG_ENDIAN)
 
 /** kbuffer
  * @timestamp       - timestamp of current event
  * @lost_events     - # of lost events between this subbuffer and previous
  * @flags       - special flags of the kbuffer
  * @subbuffer       - pointer to the sub-buffer page
  * @data        - pointer to the start of data on the sub-buffer page
  * @index       - index from @data to the @curr event data
  * @curr        - offset from @data to the start of current event
  *             (includes metadata)
  * @next        - offset from @data to the start of next event
  * @size        - The size of data on @data
  * @start       - The offset from @subbuffer where @data lives
  *
  * @read_4      - Function to read 4 raw bytes (may swap)
  * @read_8      - Function to read 8 raw bytes (may swap)
  * @read_long       - Function to read a long word (4 or 8 bytes with needed swap)
  */
 struct kbuffer {
     unsigned long long  timestamp;
     long long       lost_events;
     unsigned long       flags;
     void            *subbuffer;
     void            *data;
     unsigned int        index;
     unsigned int        curr;
     unsigned int        next;
     unsigned int        size;
     unsigned int        start;
 
     unsigned int (*read_4)(void *ptr);
     unsigned long long (*read_8)(void *ptr);
     unsigned long long (*read_long)(struct kbuffer *kbuf, void *ptr);
     int (*next_event)(struct kbuffer *kbuf);
 };
 
 static void *zmalloc(size_t size)
 {
     return calloc(1, size);
 }
 
 static int host_is_bigendian(void)
 {
     unsigned char str[] = { 0x1, 0x2, 0x3, 0x4 };
     unsigned int *ptr;
 
     ptr = (unsigned int *)str;
     return *ptr == 0x01020304;
 }
 
 static int do_swap(struct kbuffer *kbuf)
 {
     return ((kbuf->flags & KBUFFER_FL_HOST_BIG_ENDIAN) + kbuf->flags) &
         ENDIAN_MASK;
 }
 
 static unsigned long long __read_8(void *ptr)
 {
     unsigned long long data = *(unsigned long long *)ptr;
 
     return data;
 }
 
 static unsigned long long __read_8_sw(void *ptr)
 {
     unsigned long long data = *(unsigned long long *)ptr;
     unsigned long long swap;
 
     swap = ((data & 0xffULL) << 56) |
         ((data & (0xffULL << 8)) << 40) |
         ((data & (0xffULL << 16)) << 24) |
         ((data & (0xffULL << 24)) << 8) |
         ((data & (0xffULL << 32)) >> 8) |
         ((data & (0xffULL << 40)) >> 24) |
         ((data & (0xffULL << 48)) >> 40) |
         ((data & (0xffULL << 56)) >> 56);
 
     return swap;
 }
 
 static unsigned int __read_4(void *ptr)
 {
     unsigned int data = *(unsigned int *)ptr;
 
     return data;
 }
 
 static unsigned int __read_4_sw(void *ptr)
 {
     unsigned int data = *(unsigned int *)ptr;
     unsigned int swap;
 
     swap = ((data & 0xffULL) << 24) |
         ((data & (0xffULL << 8)) << 8) |
         ((data & (0xffULL << 16)) >> 8) |
         ((data & (0xffULL << 24)) >> 24);
 
     return swap;
 }
 
 static unsigned long long read_8(struct kbuffer *kbuf, void *ptr)
 {
     return kbuf->read_8(ptr);
 }
 
 static unsigned int read_4(struct kbuffer *kbuf, void *ptr)
 {
     return kbuf->read_4(ptr);
 }
 
 static unsigned long long __read_long_8(struct kbuffer *kbuf, void *ptr)
 {
     return kbuf->read_8(ptr);
 }
 
 static unsigned long long __read_long_4(struct kbuffer *kbuf, void *ptr)
 {
     return kbuf->read_4(ptr);
 }
 
 static unsigned long long read_long(struct kbuffer *kbuf, void *ptr)
 {
     return kbuf->read_long(kbuf, ptr);
 }
 
 static int calc_index(struct kbuffer *kbuf, void *ptr)
 {
     return (unsigned long)ptr - (unsigned long)kbuf->data;
 }
 
 static int __next_event(struct kbuffer *kbuf);
 
 /**
  * kbuffer_alloc - allocat a new kbuffer
  * @size;   enum to denote size of word
  * @endian: enum to denote endianness
  *
  * Allocates and returns a new kbuffer.
  */
 struct kbuffer *
 kbuffer_alloc(enum kbuffer_long_size size, enum kbuffer_endian endian)
 {
     struct kbuffer *kbuf;
     int flags = 0;
 
     switch (size) {
     case KBUFFER_LSIZE_4:
         break;
     case KBUFFER_LSIZE_8:
         flags |= KBUFFER_FL_LONG_8;
         break;
     default:
         return NULL;
     }
 
     switch (endian) {
     case KBUFFER_ENDIAN_LITTLE:
         break;
     case KBUFFER_ENDIAN_BIG:
         flags |= KBUFFER_FL_BIG_ENDIAN;
         break;
     default:
         return NULL;
     }
 
     kbuf = zmalloc(sizeof(*kbuf));
     if (!kbuf)
         return NULL;
 
     kbuf->flags = flags;
 
     if (host_is_bigendian())
         kbuf->flags |= KBUFFER_FL_HOST_BIG_ENDIAN;
 
     if (do_swap(kbuf)) {
         kbuf->read_8 = __read_8_sw;
         kbuf->read_4 = __read_4_sw;
     } else {
         kbuf->read_8 = __read_8;
         kbuf->read_4 = __read_4;
     }
 
     if (kbuf->flags & KBUFFER_FL_LONG_8)
         kbuf->read_long = __read_long_8;
     else
         kbuf->read_long = __read_long_4;
 
     /* May be changed by kbuffer_set_old_format() */
     kbuf->next_event = __next_event;
 
     return kbuf;
 }
 
 /** kbuffer_free - free an allocated kbuffer
  * @kbuf:   The kbuffer to free
  *
  * Can take NULL as a parameter.
  */
 void kbuffer_free(struct kbuffer *kbuf)
 {
     free(kbuf);
 }
 
 static unsigned int type4host(struct kbuffer *kbuf,
                   unsigned int type_len_ts)
 {
     if (kbuf->flags & KBUFFER_FL_BIG_ENDIAN)
         return (type_len_ts >> 29) & 3;
     else
         return type_len_ts & 3;
 }
 
 static unsigned int len4host(struct kbuffer *kbuf,
                  unsigned int type_len_ts)
 {
     if (kbuf->flags & KBUFFER_FL_BIG_ENDIAN)
         return (type_len_ts >> 27) & 7;
     else
         return (type_len_ts >> 2) & 7;
 }
 
 static unsigned int type_len4host(struct kbuffer *kbuf,
                   unsigned int type_len_ts)
 {
     if (kbuf->flags & KBUFFER_FL_BIG_ENDIAN)
         return (type_len_ts >> 27) & ((1 << 5) - 1);
     else
         return type_len_ts & ((1 << 5) - 1);
 }
 
 static unsigned int ts4host(struct kbuffer *kbuf,
                 unsigned int type_len_ts)
 {
     if (kbuf->flags & KBUFFER_FL_BIG_ENDIAN)
         return type_len_ts & ((1 << 27) - 1);
     else
         return type_len_ts >> 5;
 }
 
 /*
  * Linux 2.6.30 and earlier (not much ealier) had a different
  * ring buffer format. It should be obsolete, but we handle it anyway.
  */
 enum old_ring_buffer_type {
     OLD_RINGBUF_TYPE_PADDING,
     OLD_RINGBUF_TYPE_TIME_EXTEND,
     OLD_RINGBUF_TYPE_TIME_STAMP,
     OLD_RINGBUF_TYPE_DATA,
 };
 
 static unsigned int old_update_pointers(struct kbuffer *kbuf)
 {
     unsigned long long extend;
     unsigned int type_len_ts;
     unsigned int type;
     unsigned int len;
     unsigned int delta;
     unsigned int length;
     void *ptr = kbuf->data + kbuf->curr;
 
     type_len_ts = read_4(kbuf, ptr);
     ptr += 4;
 
     type = type4host(kbuf, type_len_ts);
     len = len4host(kbuf, type_len_ts);
     delta = ts4host(kbuf, type_len_ts);
 
     switch (type) {
     case OLD_RINGBUF_TYPE_PADDING:
         kbuf->next = kbuf->size;
         return 0;
 
     case OLD_RINGBUF_TYPE_TIME_EXTEND:
         extend = read_4(kbuf, ptr);
         extend <<= TS_SHIFT;
         extend += delta;
         delta = extend;
         ptr += 4;
         length = 0;
         break;
 
     case OLD_RINGBUF_TYPE_TIME_STAMP:
         /* should never happen! */
         kbuf->curr = kbuf->size;
         kbuf->next = kbuf->size;
         kbuf->index = kbuf->size;
         return -1;
     default:
         if (len)
             length = len * 4;
         else {
             length = read_4(kbuf, ptr);
             length -= 4;
             ptr += 4;
         }
         break;
     }
 
     kbuf->timestamp += delta;
     kbuf->index = calc_index(kbuf, ptr);
     kbuf->next = kbuf->index + length;
 
     return type;
 }
 
 static int __old_next_event(struct kbuffer *kbuf)
 {
     int type;
 
     do {
         kbuf->curr = kbuf->next;
         if (kbuf->next >= kbuf->size)
             return -1;
         type = old_update_pointers(kbuf);
     } while (type == OLD_RINGBUF_TYPE_TIME_EXTEND || type == OLD_RINGBUF_TYPE_PADDING);
 
     return 0;
 }
 
 static unsigned int
 translate_data(struct kbuffer *kbuf, void *data, void **rptr,
            unsigned long long *delta, int *length)
 {
     unsigned long long extend;
     unsigned int type_len_ts;
     unsigned int type_len;
 
     type_len_ts = read_4(kbuf, data);
     data += 4;
 
     type_len = type_len4host(kbuf, type_len_ts);
     *delta = ts4host(kbuf, type_len_ts);
 
     switch (type_len) {
     case KBUFFER_TYPE_PADDING:
         *length = read_4(kbuf, data);
         break;
 
     case KBUFFER_TYPE_TIME_EXTEND:
     case KBUFFER_TYPE_TIME_STAMP:
         extend = read_4(kbuf, data);
         data += 4;
         extend <<= TS_SHIFT;
         extend += *delta;
         *delta = extend;
         *length = 0;
         break;
 
     case 0:
         *length = read_4(kbuf, data) - 4;
         *length = (*length + 3) & ~3;
         data += 4;
         break;
     default:
         *length = type_len * 4;
         break;
     }
 
     *rptr = data;
 
     return type_len;
 }
 
 static unsigned int update_pointers(struct kbuffer *kbuf)
 {
     unsigned long long delta;
     unsigned int type_len;
     int length;
     void *ptr = kbuf->data + kbuf->curr;
 
     type_len = translate_data(kbuf, ptr, &ptr, &delta, &length);
 
     if (type_len == KBUFFER_TYPE_TIME_STAMP)
         kbuf->timestamp = delta;
     else
         kbuf->timestamp += delta;
 
     kbuf->index = calc_index(kbuf, ptr);
     kbuf->next = kbuf->index + length;
 
     return type_len;
 }
 
 /**
  * kbuffer_translate_data - read raw data to get a record
  * @swap:   Set to 1 if bytes in words need to be swapped when read
  * @data:   The raw data to read
  * @size:   Address to store the size of the event data.
  *
  * Returns a pointer to the event data. To determine the entire
  * record size (record metadata + data) just add the difference between
  * @data and the returned value to @size.
  */
 void *kbuffer_translate_data(int swap, void *data, unsigned int *size)
 {
     unsigned long long delta;
     struct kbuffer kbuf;
     int type_len;
     int length;
     void *ptr;
 
     if (swap) {
         kbuf.read_8 = __read_8_sw;
         kbuf.read_4 = __read_4_sw;
         kbuf.flags = host_is_bigendian() ? 0 : KBUFFER_FL_BIG_ENDIAN;
     } else {
         kbuf.read_8 = __read_8;
         kbuf.read_4 = __read_4;
         kbuf.flags = host_is_bigendian() ? KBUFFER_FL_BIG_ENDIAN: 0;
     }
 
     type_len = translate_data(&kbuf, data, &ptr, &delta, &length);
     switch (type_len) {
     case KBUFFER_TYPE_PADDING:
     case KBUFFER_TYPE_TIME_EXTEND:
     case KBUFFER_TYPE_TIME_STAMP:
         return NULL;
     }
 
     *size = length;
 
     return ptr;
 }
 
 static int __next_event(struct kbuffer *kbuf)
 {
     int type;
 
     do {
         kbuf->curr = kbuf->next;
         if (kbuf->next >= kbuf->size)
             return -1;
         type = update_pointers(kbuf);
     } while (type == KBUFFER_TYPE_TIME_EXTEND ||
          type == KBUFFER_TYPE_TIME_STAMP ||
          type == KBUFFER_TYPE_PADDING);
 
     return 0;
 }
 
 static int next_event(struct kbuffer *kbuf)
 {
     return kbuf->next_event(kbuf);
 }
 
 /**
  * kbuffer_next_event - increment the current pointer
  * @kbuf:   The kbuffer to read
  * @ts:     Address to store the next record's timestamp (may be NULL to ignore)
  *
  * Increments the pointers into the subbuffer of the kbuffer to point to the
  * next event so that the next kbuffer_read_event() will return a
  * new event.
  *
  * Returns the data of the next event if a new event exists on the subbuffer,
  * NULL otherwise.
  */
 void *kbuffer_next_event(struct kbuffer *kbuf, unsigned long long *ts)
 {
     int ret;
 
     if (!kbuf || !kbuf->subbuffer)
         return NULL;
 
     ret = next_event(kbuf);
     if (ret < 0)
         return NULL;
 
     if (ts)
         *ts = kbuf->timestamp;
 
     return kbuf->data + kbuf->index;
 }
 
 /**
  * kbuffer_load_subbuffer - load a new subbuffer into the kbuffer
  * @kbuf:   The kbuffer to load
  * @subbuffer:  The subbuffer to load into @kbuf.
  *
  * Load a new subbuffer (page) into @kbuf. This will reset all
  * the pointers and update the @kbuf timestamp. The next read will
  * return the first event on @subbuffer.
  *
  * Returns 0 on succes, -1 otherwise.
  */
 int kbuffer_load_subbuffer(struct kbuffer *kbuf, void *subbuffer)
 {
     unsigned long long flags;
     void *ptr = subbuffer;
 
     if (!kbuf || !subbuffer)
         return -1;
 
     kbuf->subbuffer = subbuffer;
 
     kbuf->timestamp = read_8(kbuf, ptr);
     ptr += 8;
 
     kbuf->curr = 0;
 
     if (kbuf->flags & KBUFFER_FL_LONG_8)
         kbuf->start = 16;
     else
         kbuf->start = 12;
 
     kbuf->data = subbuffer + kbuf->start;
 
     flags = read_long(kbuf, ptr);
     kbuf->size = (unsigned int)flags & COMMIT_MASK;
 
     if (flags & MISSING_EVENTS) {
         if (flags & MISSING_STORED) {
             ptr = kbuf->data + kbuf->size;
             kbuf->lost_events = read_long(kbuf, ptr);
         } else
             kbuf->lost_events = -1;
     } else
         kbuf->lost_events = 0;
 
     kbuf->index = 0;
     kbuf->next = 0;
 
     next_event(kbuf);
 
     return 0;
 }
 
 /**
  * kbuffer_subbuf_timestamp - read the timestamp from a sub buffer
  * @kbuf:      The kbuffer to load
  * @subbuf:    The subbuffer to read from.
  *
  * Return the timestamp from a subbuffer.
  */
 unsigned long long kbuffer_subbuf_timestamp(struct kbuffer *kbuf, void *subbuf)
 {
     return kbuf->read_8(subbuf);
 }
 
 /**
  * kbuffer_ptr_delta - read the delta field from a record
  * @kbuf:      The kbuffer to load
  * @ptr:       The record in the buffe.
  *
  * Return the timestamp delta from a record
  */
 unsigned int kbuffer_ptr_delta(struct kbuffer *kbuf, void *ptr)
 {
     unsigned int type_len_ts;
 
     type_len_ts = read_4(kbuf, ptr);
     return ts4host(kbuf, type_len_ts);
 }
 
 
 /**
  * kbuffer_read_event - read the next event in the kbuffer subbuffer
  * @kbuf:   The kbuffer to read from
  * @ts:     The address to store the timestamp of the event (may be NULL to ignore)
  *
  * Returns a pointer to the data part of the current event.
  * NULL if no event is left on the subbuffer.
  */
 void *kbuffer_read_event(struct kbuffer *kbuf, unsigned long long *ts)
 {
     if (!kbuf || !kbuf->subbuffer)
         return NULL;
 
     if (kbuf->curr >= kbuf->size)
         return NULL;
 
     if (ts)
         *ts = kbuf->timestamp;
     return kbuf->data + kbuf->index;
 }
 
 /**
  * kbuffer_timestamp - Return the timestamp of the current event
  * @kbuf:   The kbuffer to read from
  *
  * Returns the timestamp of the current (next) event.
  */
 unsigned long long kbuffer_timestamp(struct kbuffer *kbuf)
 {
     return kbuf->timestamp;
 }
 
 /**
  * kbuffer_read_at_offset - read the event that is at offset
  * @kbuf:   The kbuffer to read from
  * @offset: The offset into the subbuffer
  * @ts:     The address to store the timestamp of the event (may be NULL to ignore)
  *
  * The @offset must be an index from the @kbuf subbuffer beginning.
  * If @offset is bigger than the stored subbuffer, NULL will be returned.
  *
  * Returns the data of the record that is at @offset. Note, @offset does
  * not need to be the start of the record, the offset just needs to be
  * in the record (or beginning of it).
  *
  * Note, the kbuf timestamp and pointers are updated to the
  * returned record. That is, kbuffer_read_event() will return the same
  * data and timestamp, and kbuffer_next_event() will increment from
  * this record.
  */
 void *kbuffer_read_at_offset(struct kbuffer *kbuf, int offset,
                  unsigned long long *ts)
 {
     void *data;
 
     if (offset < kbuf->start)
         offset = 0;
     else
         offset -= kbuf->start;
 
     /* Reset the buffer */
     kbuffer_load_subbuffer(kbuf, kbuf->subbuffer);
     data = kbuffer_read_event(kbuf, ts);
 
     while (kbuf->curr < offset) {
         data = kbuffer_next_event(kbuf, ts);
         if (!data)
             break;
     }
 
     return data;
 }
 
 /**
  * kbuffer_subbuffer_size - the size of the loaded subbuffer
  * @kbuf:   The kbuffer to read from
  *
  * Returns the size of the subbuffer. Note, this size is
  * where the last event resides. The stored subbuffer may actually be
  * bigger due to padding and such.
  */
 int kbuffer_subbuffer_size(struct kbuffer *kbuf)
 {
     return kbuf->size;
 }
 
 /**
  * kbuffer_curr_index - Return the index of the record
  * @kbuf:   The kbuffer to read from
  *
  * Returns the index from the start of the data part of
  * the subbuffer to the current location. Note this is not
  * from the start of the subbuffer. An index of zero will
  * point to the first record. Use kbuffer_curr_offset() for
  * the actually offset (that can be used by kbuffer_read_at_offset())
  */
 int kbuffer_curr_index(struct kbuffer *kbuf)
 {
     return kbuf->curr;
 }
 
 /**
  * kbuffer_curr_offset - Return the offset of the record
  * @kbuf:   The kbuffer to read from
  *
  * Returns the offset from the start of the subbuffer to the
  * current location.
  */
 int kbuffer_curr_offset(struct kbuffer *kbuf)
 {
     return kbuf->curr + kbuf->start;
 }
 
 /**
  * kbuffer_event_size - return the size of the event data
  * @kbuf:   The kbuffer to read
  *
  * Returns the size of the event data (the payload not counting
  * the meta data of the record) of the current event.
  */
 int kbuffer_event_size(struct kbuffer *kbuf)
 {
     return kbuf->next - kbuf->index;
 }
 
 /**
  * kbuffer_curr_size - return the size of the entire record
  * @kbuf:   The kbuffer to read
  *
  * Returns the size of the entire record (meta data and payload)
  * of the current event.
  */
 int kbuffer_curr_size(struct kbuffer *kbuf)
 {
     return kbuf->next - kbuf->curr;
 }
 
 /**
  * kbuffer_missed_events - return the # of missed events from last event.
  * @kbuf:   The kbuffer to read from
  *
  * Returns the # of missed events (if recorded) before the current
  * event. Note, only events on the beginning of a subbuffer can
  * have missed events, all other events within the buffer will be
  * zero.
  */
 int kbuffer_missed_events(struct kbuffer *kbuf)
 {
     /* Only the first event can have missed events */
     if (kbuf->curr)
         return 0;
 
     return kbuf->lost_events;
 }
 
 /**
  * kbuffer_set_old_forma - set the kbuffer to use the old format parsing
  * @kbuf:   The kbuffer to set
  *
  * This is obsolete (or should be). The first kernels to use the
  * new ring buffer had a slightly different ring buffer format
  * (2.6.30 and earlier). It is still somewhat supported by kbuffer,
  * but should not be counted on in the future.
  */
 void kbuffer_set_old_format(struct kbuffer *kbuf)
 {
     kbuf->flags |= KBUFFER_FL_OLD_FORMAT;
 
     kbuf->next_event = __old_next_event;
 }
 
 /**
  * kbuffer_start_of_data - return offset of where data starts on subbuffer
  * @kbuf:   The kbuffer
  *
  * Returns the location on the subbuffer where the data starts.
  */
 int kbuffer_start_of_data(struct kbuffer *kbuf)
 {
     return kbuf->start;
 }
 
 /**
  * kbuffer_raw_get - get raw buffer info
  * @kbuf:   The kbuffer
  * @subbuf: Start of mapped subbuffer
  * @info:   Info descriptor to fill in
  *
  * For debugging. This can return internals of the ring buffer.
  * Expects to have info->next set to what it will read.
  * The type, length and timestamp delta will be filled in, and
  * @info->next will be updated to the next element.
  * The @subbuf is used to know if the info is passed the end of
  * data and NULL will be returned if it is.
  */
 struct kbuffer_raw_info *
 kbuffer_raw_get(struct kbuffer *kbuf, void *subbuf, struct kbuffer_raw_info *info)
 {
     unsigned long long flags;
     unsigned long long delta;
     unsigned int type_len;
     unsigned int size;
     int start;
     int length;
     void *ptr = info->next;
 
     if (!kbuf || !subbuf)
         return NULL;
 
     if (kbuf->flags & KBUFFER_FL_LONG_8)
         start = 16;
     else
         start = 12;
 
     flags = read_long(kbuf, subbuf + 8);
     size = (unsigned int)flags & COMMIT_MASK;
 
     if (ptr < subbuf || ptr >= subbuf + start + size)
         return NULL;
 
     type_len = translate_data(kbuf, ptr, &ptr, &delta, &length);
 
     info->next = ptr + length;
 
     info->type = type_len;
     info->delta = delta;
     info->length = length;
 
     return info;
 }

This page was automatically generated by the 2.1.0 LXR engine. The LXR team