include/instrumentation/events/random.h

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2 #undef TRACE_SYSTEM
   3 #define TRACE_SYSTEM random
   4
   5 #if !defined(LTTNG_TRACE_RANDOM_H) || defined(TRACE_HEADER_MULTI_READ)
   6 #define LTTNG_TRACE_RANDOM_H
   7
   8 #include <lttng/tracepoint-event.h>
   9 #include <linux/writeback.h>
  10
  11 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,13,0))
  12 LTTNG_TRACEPOINT_EVENT_MAP(add_device_randomness,
  13
  14         random_add_device_randomness,
  15
  16         TP_PROTO(int bytes, unsigned long IP),
  17
  18         TP_ARGS(bytes, IP),
  19
  20         TP_FIELDS(
  21                 ctf_integer(int, bytes, bytes)
  22                 ctf_integer_hex(unsigned long, IP, IP)
  23         )
  24 )
  25 #endif
  26
  27 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,17,0))
  28 LTTNG_TRACEPOINT_EVENT_CLASS(random__mix_pool_bytes,
  29         TP_PROTO(int bytes, unsigned long IP),
  30
  31         TP_ARGS(bytes, IP),
  32
  33         TP_FIELDS(
  34                 ctf_integer(int, bytes, bytes)
  35                 ctf_integer_hex(unsigned long, IP, IP)
  36         )
  37 )
  38
  39 LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(random__mix_pool_bytes, mix_pool_bytes,
  40
  41         random_mix_pool_bytes,
  42
  43         TP_PROTO(int bytes, unsigned long IP),
  44
  45         TP_ARGS(bytes, IP)
  46 )
  47
  48 LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(random__mix_pool_bytes, mix_pool_bytes_nolock,
  49
  50         random_mix_pool_bytes_nolock,
  51
  52         TP_PROTO(int bytes, unsigned long IP),
  53
  54         TP_ARGS(bytes, IP)
  55 )
  56 #else
  57 LTTNG_TRACEPOINT_EVENT_CLASS(random__mix_pool_bytes,
  58         TP_PROTO(const char *pool_name, int bytes, unsigned long IP),
  59
  60         TP_ARGS(pool_name, bytes, IP),
  61
  62         TP_FIELDS(
  63                 ctf_string(pool_name, pool_name)
  64                 ctf_integer(int, bytes, bytes)
  65                 ctf_integer_hex(unsigned long, IP, IP)
  66         )
  67 )
  68
  69 LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(random__mix_pool_bytes, mix_pool_bytes,
  70
  71         random_mix_pool_bytes,
  72
  73         TP_PROTO(const char *pool_name, int bytes, unsigned long IP),
  74
  75         TP_ARGS(pool_name, bytes, IP)
  76 )
  77
  78 LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(random__mix_pool_bytes, mix_pool_bytes_nolock,
  79
  80         random_mix_pool_bytes_nolock,
  81
  82         TP_PROTO(const char *pool_name, int bytes, unsigned long IP),
  83
  84         TP_ARGS(pool_name, bytes, IP)
  85 )
  86 #endif
  87
  88 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,17,0))
  89 LTTNG_TRACEPOINT_EVENT_MAP(credit_entropy_bits,
  90
  91         random_credit_entropy_bits,
  92
  93         TP_PROTO(int bits, int entropy_count, unsigned long IP),
  94
  95         TP_ARGS(bits, entropy_count, IP),
  96
  97         TP_FIELDS(
  98                 ctf_integer(int, bits, bits)
  99                 ctf_integer(int, entropy_count, entropy_count)
 100                 ctf_integer_hex(unsigned long, IP, IP)
 101         )
 102 )
 103 #elif (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,2,0))
 104 LTTNG_TRACEPOINT_EVENT_MAP(credit_entropy_bits,
 105
 106         random_credit_entropy_bits,
 107
 108         TP_PROTO(const char *pool_name, int bits, int entropy_count,
 109                  unsigned long IP),
 110
 111         TP_ARGS(pool_name, bits, entropy_count, IP),
 112
 113         TP_FIELDS(
 114                 ctf_string(pool_name, pool_name)
 115                 ctf_integer(int, bits, bits)
 116                 ctf_integer(int, entropy_count, entropy_count)
 117                 ctf_integer_hex(unsigned long, IP, IP)
 118         )
 119 )
 120 #else
 121 LTTNG_TRACEPOINT_EVENT_MAP(credit_entropy_bits,
 122
 123         random_credit_entropy_bits,
 124
 125         TP_PROTO(const char *pool_name, int bits, int entropy_count,
 126                  int entropy_total, unsigned long IP),
 127
 128         TP_ARGS(pool_name, bits, entropy_count, entropy_total, IP),
 129
 130         TP_FIELDS(
 131                 ctf_string(pool_name, pool_name)
 132                 ctf_integer(int, bits, bits)
 133                 ctf_integer(int, entropy_count, entropy_count)
 134                 ctf_integer(int, entropy_total, entropy_total)
 135                 ctf_integer_hex(unsigned long, IP, IP)
 136         )
 137 )
 138 #endif
 139
 140 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,13,0))
 141 LTTNG_TRACEPOINT_EVENT_MAP(push_to_pool,
 142
 143         random_push_to_pool,
 144
 145         TP_PROTO(const char *pool_name, int pool_bits, int input_bits),
 146
 147         TP_ARGS(pool_name, pool_bits, input_bits),
 148
 149         TP_FIELDS(
 150                 ctf_string(pool_name, pool_name)
 151                 ctf_integer(int, pool_bits, pool_bits)
 152                 ctf_integer(int, input_bits, input_bits)
 153         )
 154 )
 155 #endif
 156
 157 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,17,0))
 158 LTTNG_TRACEPOINT_EVENT_MAP(debit_entropy,
 159
 160         random_debit_entropy,
 161
 162         TP_PROTO(int debit_bits),
 163
 164         TP_ARGS(debit_bits),
 165
 166         TP_FIELDS(
 167                 ctf_integer(int, debit_bits, debit_bits)
 168         )
 169 )
 170 #elif (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,13,0))
 171 LTTNG_TRACEPOINT_EVENT_MAP(debit_entropy,
 172
 173         random_debit_entropy,
 174
 175         TP_PROTO(const char *pool_name, int debit_bits),
 176
 177         TP_ARGS(pool_name, debit_bits),
 178
 179         TP_FIELDS(
 180                 ctf_string(pool_name, pool_name)
 181                 ctf_integer(int, debit_bits, debit_bits)
 182         )
 183 )
 184 #endif
 185
 186 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,13,0))
 187 LTTNG_TRACEPOINT_EVENT_MAP(add_input_randomness,
 188
 189         random_add_input_randomness,
 190
 191         TP_PROTO(int input_bits),
 192
 193         TP_ARGS(input_bits),
 194
 195         TP_FIELDS(
 196                 ctf_integer(int, input_bits, input_bits)
 197         )
 198 )
 199
 200 LTTNG_TRACEPOINT_EVENT_MAP(add_disk_randomness,
 201
 202         random_add_disk_randomness,
 203
 204         TP_PROTO(dev_t dev, int input_bits),
 205
 206         TP_ARGS(dev, input_bits),
 207
 208         TP_FIELDS(
 209                 ctf_integer(dev_t, dev, dev)
 210                 ctf_integer(int, input_bits, input_bits)
 211         )
 212 )
 213
 214 LTTNG_TRACEPOINT_EVENT_MAP(xfer_secondary_pool,
 215
 216         random_xfer_secondary_pool,
 217
 218         TP_PROTO(const char *pool_name, int xfer_bits, int request_bits,
 219                 int pool_entropy, int input_entropy),
 220
 221         TP_ARGS(pool_name, xfer_bits, request_bits, pool_entropy,
 222                 input_entropy),
 223
 224         TP_FIELDS(
 225                 ctf_string(pool_name, pool_name)
 226                 ctf_integer(int, xfer_bits, xfer_bits)
 227                 ctf_integer(int, request_bits, request_bits)
 228                 ctf_integer(int, pool_entropy, pool_entropy)
 229                 ctf_integer(int, input_entropy, input_entropy)
 230         )
 231 )
 232 #endif
 233
 234 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,13,0))
 235 LTTNG_TRACEPOINT_EVENT_CLASS(random__get_random_bytes,
 236
 237         TP_PROTO(int nbytes, unsigned long IP),
 238
 239         TP_ARGS(nbytes, IP),
 240
 241         TP_FIELDS(
 242                 ctf_integer(int, nbytes, nbytes)
 243                 ctf_integer_hex(unsigned long, IP, IP)
 244         )
 245 )
 246
 247 LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(random__get_random_bytes, get_random_bytes,
 248
 249         random_get_random_bytes,
 250
 251         TP_PROTO(int nbytes, unsigned long IP),
 252
 253         TP_ARGS(nbytes, IP)
 254 )
 255
 256 LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(random__get_random_bytes, get_random_bytes_arch,
 257
 258         random_get_random_bytes_arch,
 259
 260         TP_PROTO(int nbytes, unsigned long IP),
 261
 262         TP_ARGS(nbytes, IP)
 263 )
 264 #else
 265 LTTNG_TRACEPOINT_EVENT_MAP(get_random_bytes,
 266
 267         random_get_random_bytes,
 268
 269         TP_PROTO(int nbytes, unsigned long IP),
 270
 271         TP_ARGS(nbytes, IP),
 272
 273         TP_FIELDS(
 274                 ctf_integer(int, nbytes, nbytes)
 275                 ctf_integer_hex(unsigned long, IP, IP)
 276         )
 277 )
 278 #endif
 279
 280 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,17,0))
 281 LTTNG_TRACEPOINT_EVENT_CLASS(random__extract_entropy,
 282         TP_PROTO(int nbytes, int entropy_count, unsigned long IP),
 283
 284         TP_ARGS(nbytes, entropy_count, IP),
 285
 286         TP_FIELDS(
 287                 ctf_integer(int, nbytes, nbytes)
 288                 ctf_integer(int, entropy_count, entropy_count)
 289                 ctf_integer_hex(unsigned long, IP, IP)
 290         )
 291 )
 292
 293
 294 LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(random__extract_entropy, extract_entropy,
 295
 296         random_extract_entropy,
 297
 298         TP_PROTO(int nbytes, int entropy_count, unsigned long IP),
 299
 300         TP_ARGS(nbytes, entropy_count, IP)
 301 )
 302
 303 LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(random__extract_entropy, extract_entropy_user,
 304
 305         random_extract_entropy_user,
 306
 307         TP_PROTO(int nbytes, int entropy_count, unsigned long IP),
 308
 309         TP_ARGS(nbytes, entropy_count, IP)
 310 )
 311 #else
 312 LTTNG_TRACEPOINT_EVENT_CLASS(random__extract_entropy,
 313         TP_PROTO(const char *pool_name, int nbytes, int entropy_count,
 314                  unsigned long IP),
 315
 316         TP_ARGS(pool_name, nbytes, entropy_count, IP),
 317
 318         TP_FIELDS(
 319                 ctf_string(pool_name, pool_name)
 320                 ctf_integer(int, nbytes, nbytes)
 321                 ctf_integer(int, entropy_count, entropy_count)
 322                 ctf_integer_hex(unsigned long, IP, IP)
 323         )
 324 )
 325
 326
 327 LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(random__extract_entropy, extract_entropy,
 328
 329         random_extract_entropy,
 330
 331         TP_PROTO(const char *pool_name, int nbytes, int entropy_count,
 332                  unsigned long IP),
 333
 334         TP_ARGS(pool_name, nbytes, entropy_count, IP)
 335 )
 336
 337 LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(random__extract_entropy, extract_entropy_user,
 338
 339         random_extract_entropy_user,
 340
 341         TP_PROTO(const char *pool_name, int nbytes, int entropy_count,
 342                  unsigned long IP),
 343
 344         TP_ARGS(pool_name, nbytes, entropy_count, IP)
 345 )
 346 #endif
 347
 348 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,13,0))
 349 LTTNG_TRACEPOINT_EVENT_MAP(random_read,
 350
 351         random_random_read,
 352
 353         TP_PROTO(int got_bits, int need_bits, int pool_left, int input_left),
 354
 355         TP_ARGS(got_bits, need_bits, pool_left, input_left),
 356
 357         TP_FIELDS(
 358                 ctf_integer(int, got_bits, got_bits)
 359                 ctf_integer(int, need_bits, need_bits)
 360                 ctf_integer(int, pool_left, pool_left)
 361                 ctf_integer(int, input_left, input_left)
 362         )
 363 )
 364
 365 LTTNG_TRACEPOINT_EVENT_MAP(urandom_read,
 366
 367         random_urandom_read,
 368
 369         TP_PROTO(int got_bits, int pool_left, int input_left),
 370
 371         TP_ARGS(got_bits, pool_left, input_left),
 372
 373         TP_FIELDS(
 374                 ctf_integer(int, got_bits, got_bits)
 375                 ctf_integer(int, pool_left, pool_left)
 376                 ctf_integer(int, input_left, input_left)
 377         )
 378 )
 379 #endif
 380
 381 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,9,0))
 382 LTTNG_TRACEPOINT_EVENT_MAP(prandom_u32,
 383
 384         random_prandom_u32,
 385
 386         TP_PROTO(unsigned int ret),
 387
 388         TP_ARGS(ret),
 389
 390         TP_FIELDS(
 391                 ctf_integer(unsigned int, ret, ret)
 392         )
 393 )
 394 #endif
 395
 396
 397 #endif /* LTTNG_TRACE_RANDOM_H */
 398
 399 /* This part must be outside protection */
 400 #include <lttng/define_trace.h>