tools/lib/traceevent/event-parse-api.c

   1 // SPDX-License-Identifier: LGPL-2.1
   2 /*
   3  * Copyright (C) 2009, 2010 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
   4  *
   5  */
   6
   7 #include "event-parse.h"
   8 #include "event-parse-local.h"
   9 #include "event-utils.h"
  10
  11 /**
  12  * tep_get_event - returns the event with the given index
  13  * @tep: a handle to the tep_handle
  14  * @index: index of the requested event, in the range 0 .. nr_events
  15  *
  16  * This returns pointer to the element of the events array with the given index
  17  * If @tep is NULL, or @index is not in the range 0 .. nr_events, NULL is returned.
  18  */
  19 struct tep_event *tep_get_event(struct tep_handle *tep, int index)
  20 {
  21         if (tep && tep->events && index < tep->nr_events)
  22                 return tep->events[index];
  23
  24         return NULL;
  25 }
  26
  27 /**
  28  * tep_get_first_event - returns the first event in the events array
  29  * @tep: a handle to the tep_handle
  30  *
  31  * This returns pointer to the first element of the events array
  32  * If @tep is NULL, NULL is returned.
  33  */
  34 struct tep_event *tep_get_first_event(struct tep_handle *tep)
  35 {
  36         return tep_get_event(tep, 0);
  37 }
  38
  39 /**
  40  * tep_get_events_count - get the number of defined events
  41  * @tep: a handle to the tep_handle
  42  *
  43  * This returns number of elements in event array
  44  * If @tep is NULL, 0 is returned.
  45  */
  46 int tep_get_events_count(struct tep_handle *tep)
  47 {
  48         if (tep)
  49                 return tep->nr_events;
  50         return 0;
  51 }
  52
  53 /**
  54  * tep_set_flag - set event parser flag
  55  * @tep: a handle to the tep_handle
  56  * @flag: flag, or combination of flags to be set
  57  * can be any combination from enum tep_flag
  58  *
  59  * This sets a flag or combination of flags from enum tep_flag
  60  */
  61 void tep_set_flag(struct tep_handle *tep, int flag)
  62 {
  63         if (tep)
  64                 tep->flags |= flag;
  65 }
  66
  67 /**
  68  * tep_clear_flag - clear event parser flag
  69  * @tep: a handle to the tep_handle
  70  * @flag: flag to be cleared
  71  *
  72  * This clears a tep flag
  73  */
  74 void tep_clear_flag(struct tep_handle *tep, enum tep_flag flag)
  75 {
  76         if (tep)
  77                 tep->flags &= ~flag;
  78 }
  79
  80 /**
  81  * tep_test_flag - check the state of event parser flag
  82  * @tep: a handle to the tep_handle
  83  * @flag: flag to be checked
  84  *
  85  * This returns the state of the requested tep flag.
  86  * Returns: true if the flag is set, false otherwise.
  87  */
  88 bool tep_test_flag(struct tep_handle *tep, enum tep_flag flag)
  89 {
  90         if (tep)
  91                 return tep->flags & flag;
  92         return false;
  93 }
  94
  95 unsigned short tep_data2host2(struct tep_handle *tep, unsigned short data)
  96 {
  97         unsigned short swap;
  98
  99         if (!tep || tep->host_bigendian == tep->file_bigendian)
 100                 return data;
 101
 102         swap = ((data & 0xffULL) << 8) |
 103                 ((data & (0xffULL << 8)) >> 8);
 104
 105         return swap;
 106 }
 107
 108 unsigned int tep_data2host4(struct tep_handle *tep, unsigned int data)
 109 {
 110         unsigned int swap;
 111
 112         if (!tep || tep->host_bigendian == tep->file_bigendian)
 113                 return data;
 114
 115         swap = ((data & 0xffULL) << 24) |
 116                 ((data & (0xffULL << 8)) << 8) |
 117                 ((data & (0xffULL << 16)) >> 8) |
 118                 ((data & (0xffULL << 24)) >> 24);
 119
 120         return swap;
 121 }
 122
 123 unsigned long long
 124 tep_data2host8(struct tep_handle *tep, unsigned long long data)
 125 {
 126         unsigned long long swap;
 127
 128         if (!tep || tep->host_bigendian == tep->file_bigendian)
 129                 return data;
 130
 131         swap = ((data & 0xffULL) << 56) |
 132                 ((data & (0xffULL << 8)) << 40) |
 133                 ((data & (0xffULL << 16)) << 24) |
 134                 ((data & (0xffULL << 24)) << 8) |
 135                 ((data & (0xffULL << 32)) >> 8) |
 136                 ((data & (0xffULL << 40)) >> 24) |
 137                 ((data & (0xffULL << 48)) >> 40) |
 138                 ((data & (0xffULL << 56)) >> 56);
 139
 140         return swap;
 141 }
 142
 143 /**
 144  * tep_get_header_page_size - get size of the header page
 145  * @tep: a handle to the tep_handle
 146  *
 147  * This returns size of the header page
 148  * If @tep is NULL, 0 is returned.
 149  */
 150 int tep_get_header_page_size(struct tep_handle *tep)
 151 {
 152         if (tep)
 153                 return tep->header_page_size_size;
 154         return 0;
 155 }
 156
 157 /**
 158  * tep_get_header_timestamp_size - get size of the timestamp in the header page
 159  * @tep: a handle to the tep_handle
 160  *
 161  * This returns size of the timestamp in the header page
 162  * If @tep is NULL, 0 is returned.
 163  */
 164 int tep_get_header_timestamp_size(struct tep_handle *tep)
 165 {
 166         if (tep)
 167                 return tep->header_page_ts_size;
 168         return 0;
 169 }
 170
 171 /**
 172  * tep_get_cpus - get the number of CPUs
 173  * @tep: a handle to the tep_handle
 174  *
 175  * This returns the number of CPUs
 176  * If @tep is NULL, 0 is returned.
 177  */
 178 int tep_get_cpus(struct tep_handle *tep)
 179 {
 180         if (tep)
 181                 return tep->cpus;
 182         return 0;
 183 }
 184
 185 /**
 186  * tep_set_cpus - set the number of CPUs
 187  * @tep: a handle to the tep_handle
 188  *
 189  * This sets the number of CPUs
 190  */
 191 void tep_set_cpus(struct tep_handle *tep, int cpus)
 192 {
 193         if (tep)
 194                 tep->cpus = cpus;
 195 }
 196
 197 /**
 198  * tep_get_long_size - get the size of a long integer on the traced machine
 199  * @tep: a handle to the tep_handle
 200  *
 201  * This returns the size of a long integer on the traced machine
 202  * If @tep is NULL, 0 is returned.
 203  */
 204 int tep_get_long_size(struct tep_handle *tep)
 205 {
 206         if (tep)
 207                 return tep->long_size;
 208         return 0;
 209 }
 210
 211 /**
 212  * tep_set_long_size - set the size of a long integer on the traced machine
 213  * @tep: a handle to the tep_handle
 214  * @size: size, in bytes, of a long integer
 215  *
 216  * This sets the size of a long integer on the traced machine
 217  */
 218 void tep_set_long_size(struct tep_handle *tep, int long_size)
 219 {
 220         if (tep)
 221                 tep->long_size = long_size;
 222 }
 223
 224 /**
 225  * tep_get_page_size - get the size of a memory page on the traced machine
 226  * @tep: a handle to the tep_handle
 227  *
 228  * This returns the size of a memory page on the traced machine
 229  * If @tep is NULL, 0 is returned.
 230  */
 231 int tep_get_page_size(struct tep_handle *tep)
 232 {
 233         if (tep)
 234                 return tep->page_size;
 235         return 0;
 236 }
 237
 238 /**
 239  * tep_set_page_size - set the size of a memory page on the traced machine
 240  * @tep: a handle to the tep_handle
 241  * @_page_size: size of a memory page, in bytes
 242  *
 243  * This sets the size of a memory page on the traced machine
 244  */
 245 void tep_set_page_size(struct tep_handle *tep, int _page_size)
 246 {
 247         if (tep)
 248                 tep->page_size = _page_size;
 249 }
 250
 251 /**
 252  * tep_is_file_bigendian - return the endian of the file
 253  * @tep: a handle to the tep_handle
 254  *
 255  * This returns true if the file is in big endian order
 256  * If @tep is NULL, false is returned.
 257  */
 258 bool tep_is_file_bigendian(struct tep_handle *tep)
 259 {
 260         if (tep)
 261                 return (tep->file_bigendian == TEP_BIG_ENDIAN);
 262         return false;
 263 }
 264
 265 /**
 266  * tep_set_file_bigendian - set if the file is in big endian order
 267  * @tep: a handle to the tep_handle
 268  * @endian: non zero, if the file is in big endian order
 269  *
 270  * This sets if the file is in big endian order
 271  */
 272 void tep_set_file_bigendian(struct tep_handle *tep, enum tep_endian endian)
 273 {
 274         if (tep)
 275                 tep->file_bigendian = endian;
 276 }
 277
 278 /**
 279  * tep_is_local_bigendian - return the endian of the saved local machine
 280  * @tep: a handle to the tep_handle
 281  *
 282  * This returns true if the saved local machine in @tep is big endian.
 283  * If @tep is NULL, false is returned.
 284  */
 285 bool tep_is_local_bigendian(struct tep_handle *tep)
 286 {
 287         if (tep)
 288                 return (tep->host_bigendian == TEP_BIG_ENDIAN);
 289         return 0;
 290 }
 291
 292 /**
 293  * tep_set_local_bigendian - set the stored local machine endian order
 294  * @tep: a handle to the tep_handle
 295  * @endian: non zero, if the local host has big endian order
 296  *
 297  * This sets the endian order for the local machine.
 298  */
 299 void tep_set_local_bigendian(struct tep_handle *tep, enum tep_endian endian)
 300 {
 301         if (tep)
 302                 tep->host_bigendian = endian;
 303 }
 304
 305 /**
 306  * tep_is_latency_format - get if the latency output format is configured
 307  * @tep: a handle to the tep_handle
 308  *
 309  * This returns true if the latency output format is configured
 310  * If @tep is NULL, false is returned.
 311  */
 312 bool tep_is_latency_format(struct tep_handle *tep)
 313 {
 314         if (tep)
 315                 return (tep->latency_format);
 316         return false;
 317 }
 318
 319 /**
 320  * tep_set_latency_format - set the latency output format
 321  * @tep: a handle to the tep_handle
 322  * @lat: non zero for latency output format
 323  *
 324  * This sets the latency output format
 325   */
 326 void tep_set_latency_format(struct tep_handle *tep, int lat)
 327 {
 328         if (tep)
 329                 tep->latency_format = lat;
 330 }
 331
 332 /**
 333  * tep_is_old_format - get if an old kernel is used
 334  * @tep: a handle to the tep_handle
 335  *
 336  * This returns true, if an old kernel is used to generate the tracing events or
 337  * false if a new kernel is used. Old kernels did not have header page info.
 338  * If @tep is NULL, false is returned.
 339  */
 340 bool tep_is_old_format(struct tep_handle *tep)
 341 {
 342         if (tep)
 343                 return tep->old_format;
 344         return false;
 345 }
 346
 347 /**
 348  * tep_set_print_raw - set a flag to force print in raw format
 349  * @tep: a handle to the tep_handle
 350  * @print_raw: the new value of the print_raw flag
 351  *
 352  * This sets a flag to force print in raw format
 353  */
 354 void tep_set_print_raw(struct tep_handle *tep, int print_raw)
 355 {
 356         if (tep)
 357                 tep->print_raw = print_raw;
 358 }
 359
 360 /**
 361  * tep_set_test_filters - set a flag to test a filter string
 362  * @tep: a handle to the tep_handle
 363  * @test_filters: the new value of the test_filters flag
 364  *
 365  * This sets a flag to test a filter string. If this flag is set, when
 366  * tep_filter_add_filter_str() API as called,it will print the filter string
 367  * instead of adding it.
 368  */
 369 void tep_set_test_filters(struct tep_handle *tep, int test_filters)
 370 {
 371         if (tep)
 372                 tep->test_filters = test_filters;
 373 }