instrumentation/events/lttng-module/mm_vmscan.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #undef TRACE_SYSTEM
   3 #define TRACE_SYSTEM mm_vmscan
   4
   5 #if !defined(LTTNG_TRACE_MM_VMSCAN_H) || defined(TRACE_HEADER_MULTI_READ)
   6 #define LTTNG_TRACE_MM_VMSCAN_H
   7
   8 #include <probes/lttng-tracepoint-event.h>
   9 #include <linux/types.h>
  10 #include <linux/mm.h>
  11 #include <linux/memcontrol.h>
  12 #include <linux/version.h>
  13
  14 #ifndef _TRACE_VMSCAN_DEF
  15 #define _TRACE_VMSCAN_DEF
  16 #define RECLAIM_WB_ANON         0x0001u
  17 #define RECLAIM_WB_FILE         0x0002u
  18 #define RECLAIM_WB_MIXED        0x0010u
  19 #define RECLAIM_WB_SYNC         0x0004u /* Unused, all reclaim async */
  20 #define RECLAIM_WB_ASYNC        0x0008u
  21
  22 #if ((LINUX_VERSION_CODE <= KERNEL_VERSION(3,0,38)) || \
  23         LTTNG_KERNEL_RANGE(3,1,0, 3,2,0))
  24 typedef int isolate_mode_t;
  25 #endif
  26
  27 #endif
  28
  29 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,2,0))
  30
  31 #include <linux/mm_inline.h>
  32
  33 #define trace_reclaim_flags(file) ( \
  34         (file ? RECLAIM_WB_FILE : RECLAIM_WB_ANON) | \
  35         (RECLAIM_WB_ASYNC) \
  36         )
  37
  38 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,5,0))
  39
  40 #include <linux/mm_inline.h>
  41
  42 #define trace_reclaim_flags(page) ( \
  43         (page_is_file_cache(page) ? RECLAIM_WB_FILE : RECLAIM_WB_ANON) | \
  44         (RECLAIM_WB_ASYNC) \
  45         )
  46
  47 #define trace_shrink_flags(file) \
  48         ( \
  49                 (file ? RECLAIM_WB_FILE : RECLAIM_WB_ANON) | \
  50                 (RECLAIM_WB_ASYNC) \
  51         )
  52
  53 #endif
  54
  55 LTTNG_TRACEPOINT_EVENT(mm_vmscan_kswapd_sleep,
  56
  57         TP_PROTO(int nid),
  58
  59         TP_ARGS(nid),
  60
  61         TP_FIELDS(
  62                 ctf_integer(int, nid, nid)
  63         )
  64 )
  65
  66 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,8,0))
  67
  68 LTTNG_TRACEPOINT_EVENT(mm_vmscan_kswapd_wake,
  69
  70         TP_PROTO(int nid, int zid, int order),
  71
  72         TP_ARGS(nid, zid, order),
  73
  74         TP_FIELDS(
  75                 ctf_integer(int, nid, nid)
  76                 ctf_integer(int, zid, zid)
  77                 ctf_integer(int, order, order)
  78         )
  79 )
  80
  81 #else
  82
  83 LTTNG_TRACEPOINT_EVENT(mm_vmscan_kswapd_wake,
  84
  85         TP_PROTO(int nid, int order),
  86
  87         TP_ARGS(nid, order),
  88
  89         TP_FIELDS(
  90                 ctf_integer(int, nid, nid)
  91                 ctf_integer(int, order, order)
  92         )
  93 )
  94
  95 #endif
  96
  97 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,17,0))
  98 LTTNG_TRACEPOINT_EVENT(mm_vmscan_wakeup_kswapd,
  99
 100         TP_PROTO(int nid, int zid, int order, gfp_t gfp_flags),
 101
 102         TP_ARGS(nid, zid, order, gfp_flags),
 103
 104         TP_FIELDS(
 105                 ctf_integer(int, nid, nid)
 106                 ctf_integer(int, zid, zid)
 107                 ctf_integer(int, order, order)
 108                 ctf_integer(gfp_t, gfp_flags, gfp_flags)
 109         )
 110 )
 111 #else
 112 LTTNG_TRACEPOINT_EVENT(mm_vmscan_wakeup_kswapd,
 113
 114         TP_PROTO(int nid, int zid, int order),
 115
 116         TP_ARGS(nid, zid, order),
 117
 118         TP_FIELDS(
 119                 ctf_integer(int, nid, nid)
 120                 ctf_integer(int, zid, zid)
 121                 ctf_integer(int, order, order)
 122         )
 123 )
 124 #endif
 125
 126 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,2,0))
 127
 128 LTTNG_TRACEPOINT_EVENT_CLASS(mm_vmscan_direct_reclaim_begin_template,
 129
 130         TP_PROTO(int order, gfp_t gfp_flags),
 131
 132         TP_ARGS(order, gfp_flags),
 133
 134         TP_FIELDS(
 135                 ctf_integer(int, order, order)
 136                 ctf_integer(gfp_t, gfp_flags, gfp_flags)
 137         )
 138 )
 139
 140 LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_direct_reclaim_begin_template, mm_vmscan_direct_reclaim_begin,
 141
 142         TP_PROTO(int order, gfp_t gfp_flags),
 143
 144         TP_ARGS(order, gfp_flags)
 145 )
 146
 147 LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_direct_reclaim_begin_template, mm_vmscan_memcg_reclaim_begin,
 148
 149         TP_PROTO(int order, gfp_t gfp_flags),
 150
 151         TP_ARGS(order, gfp_flags)
 152 )
 153
 154 LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_direct_reclaim_begin_template, mm_vmscan_memcg_softlimit_reclaim_begin,
 155
 156         TP_PROTO(int order, gfp_t gfp_flags),
 157
 158         TP_ARGS(order, gfp_flags)
 159 )
 160
 161 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,8,0))
 162
 163 LTTNG_TRACEPOINT_EVENT_CLASS(mm_vmscan_direct_reclaim_begin_template,
 164
 165         TP_PROTO(int order, int may_writepage, gfp_t gfp_flags, int classzone_idx),
 166
 167         TP_ARGS(order, may_writepage, gfp_flags, classzone_idx),
 168
 169         TP_FIELDS(
 170                 ctf_integer(int, order, order)
 171                 ctf_integer(int, may_writepage, may_writepage)
 172                 ctf_integer(gfp_t, gfp_flags, gfp_flags)
 173                 ctf_integer(int, classzone_idx, classzone_idx)
 174         )
 175 )
 176
 177 LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_direct_reclaim_begin_template, mm_vmscan_direct_reclaim_begin,
 178
 179         TP_PROTO(int order, int may_writepage, gfp_t gfp_flags, int classzone_idx),
 180
 181         TP_ARGS(order, may_writepage, gfp_flags, classzone_idx)
 182 )
 183
 184 LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_direct_reclaim_begin_template, mm_vmscan_memcg_reclaim_begin,
 185
 186         TP_PROTO(int order, int may_writepage, gfp_t gfp_flags, int classzone_idx),
 187
 188         TP_ARGS(order, may_writepage, gfp_flags, classzone_idx)
 189 )
 190
 191 LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_direct_reclaim_begin_template, mm_vmscan_memcg_softlimit_reclaim_begin,
 192
 193         TP_PROTO(int order, int may_writepage, gfp_t gfp_flags, int classzone_idx),
 194
 195         TP_ARGS(order, may_writepage, gfp_flags, classzone_idx)
 196 )
 197
 198 #else
 199
 200 LTTNG_TRACEPOINT_EVENT_CLASS(mm_vmscan_direct_reclaim_begin_template,
 201
 202         TP_PROTO(int order, int may_writepage, gfp_t gfp_flags),
 203
 204         TP_ARGS(order, may_writepage, gfp_flags),
 205
 206         TP_FIELDS(
 207                 ctf_integer(int, order, order)
 208                 ctf_integer(int, may_writepage, may_writepage)
 209                 ctf_integer(gfp_t, gfp_flags, gfp_flags)
 210         )
 211 )
 212
 213 LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_direct_reclaim_begin_template, mm_vmscan_direct_reclaim_begin,
 214
 215         TP_PROTO(int order, int may_writepage, gfp_t gfp_flags),
 216
 217         TP_ARGS(order, may_writepage, gfp_flags)
 218 )
 219
 220 LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_direct_reclaim_begin_template, mm_vmscan_memcg_reclaim_begin,
 221
 222         TP_PROTO(int order, int may_writepage, gfp_t gfp_flags),
 223
 224         TP_ARGS(order, may_writepage, gfp_flags)
 225 )
 226
 227 LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_direct_reclaim_begin_template, mm_vmscan_memcg_softlimit_reclaim_begin,
 228
 229         TP_PROTO(int order, int may_writepage, gfp_t gfp_flags),
 230
 231         TP_ARGS(order, may_writepage, gfp_flags)
 232 )
 233
 234 #endif
 235
 236 LTTNG_TRACEPOINT_EVENT_CLASS(mm_vmscan_direct_reclaim_end_template,
 237
 238         TP_PROTO(unsigned long nr_reclaimed),
 239
 240         TP_ARGS(nr_reclaimed),
 241
 242         TP_FIELDS(
 243                 ctf_integer(unsigned long, nr_reclaimed, nr_reclaimed)
 244         )
 245 )
 246
 247 LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_direct_reclaim_end_template, mm_vmscan_direct_reclaim_end,
 248
 249         TP_PROTO(unsigned long nr_reclaimed),
 250
 251         TP_ARGS(nr_reclaimed)
 252 )
 253
 254 LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_direct_reclaim_end_template, mm_vmscan_memcg_reclaim_end,
 255
 256         TP_PROTO(unsigned long nr_reclaimed),
 257
 258         TP_ARGS(nr_reclaimed)
 259 )
 260
 261 LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_direct_reclaim_end_template, mm_vmscan_memcg_softlimit_reclaim_end,
 262
 263         TP_PROTO(unsigned long nr_reclaimed),
 264
 265         TP_ARGS(nr_reclaimed)
 266 )
 267
 268 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,16,0))
 269 LTTNG_TRACEPOINT_EVENT_MAP(mm_shrink_slab_start,
 270
 271         mm_vmscan_shrink_slab_start,
 272
 273         TP_PROTO(struct shrinker *shr, struct shrink_control *sc,
 274                 long nr_objects_to_shrink, unsigned long cache_items,
 275                 unsigned long long delta, unsigned long total_scan,
 276                 int priority),
 277
 278         TP_ARGS(shr, sc, nr_objects_to_shrink, cache_items, delta, total_scan,
 279                 priority),
 280
 281         TP_FIELDS(
 282                 ctf_integer_hex(struct shrinker *, shr, shr)
 283                 ctf_integer_hex(void *, shrink, shr->scan_objects)
 284                 ctf_integer(int, nid, sc->nid)
 285                 ctf_integer(long, nr_objects_to_shrink, nr_objects_to_shrink)
 286                 ctf_integer(gfp_t, gfp_flags, sc->gfp_mask)
 287                 ctf_integer(unsigned long, cache_items, cache_items)
 288                 ctf_integer(unsigned long long, delta, delta)
 289                 ctf_integer(unsigned long, total_scan, total_scan)
 290                 ctf_integer(int, priority, priority)
 291         )
 292 )
 293 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
 294 LTTNG_TRACEPOINT_EVENT_MAP(mm_shrink_slab_start,
 295
 296         mm_vmscan_shrink_slab_start,
 297
 298         TP_PROTO(struct shrinker *shr, struct shrink_control *sc,
 299                 long nr_objects_to_shrink, unsigned long pgs_scanned,
 300                 unsigned long lru_pgs, unsigned long cache_items,
 301                 unsigned long long delta, unsigned long total_scan),
 302
 303         TP_ARGS(shr, sc, nr_objects_to_shrink, pgs_scanned, lru_pgs,
 304                 cache_items, delta, total_scan),
 305
 306         TP_FIELDS(
 307                 ctf_integer_hex(struct shrinker *, shr, shr)
 308 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0))
 309                 ctf_integer_hex(void *, shrink, shr->scan_objects)
 310 #else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0)) */
 311                 ctf_integer_hex(void *, shrink, shr->shrink)
 312 #endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0)) */
 313                 ctf_integer(long, nr_objects_to_shrink, nr_objects_to_shrink)
 314                 ctf_integer(gfp_t, gfp_flags, sc->gfp_mask)
 315                 ctf_integer(unsigned long, pgs_scanned, pgs_scanned)
 316                 ctf_integer(unsigned long, lru_pgs, lru_pgs)
 317                 ctf_integer(unsigned long, cache_items, cache_items)
 318                 ctf_integer(unsigned long long, delta, delta)
 319                 ctf_integer(unsigned long, total_scan, total_scan)
 320         )
 321 )
 322 #endif
 323
 324 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,16,0))
 325 LTTNG_TRACEPOINT_EVENT_MAP(mm_shrink_slab_end,
 326
 327         mm_vmscan_shrink_slab_end,
 328
 329         TP_PROTO(struct shrinker *shr, int nid, int shrinker_retval,
 330                 long unused_scan_cnt, long new_scan_cnt, long total_scan),
 331
 332         TP_ARGS(shr, nid, shrinker_retval, unused_scan_cnt, new_scan_cnt,
 333                 total_scan),
 334
 335         TP_FIELDS(
 336                 ctf_integer_hex(struct shrinker *, shr, shr)
 337                 ctf_integer(int, nid, nid)
 338                 ctf_integer_hex(void *, shrink, shr->scan_objects)
 339                 ctf_integer(long, unused_scan, unused_scan_cnt)
 340                 ctf_integer(long, new_scan, new_scan_cnt)
 341                 ctf_integer(int, retval, shrinker_retval)
 342                 ctf_integer(long, total_scan, total_scan)
 343         )
 344 )
 345 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
 346 LTTNG_TRACEPOINT_EVENT_MAP(mm_shrink_slab_end,
 347
 348         mm_vmscan_shrink_slab_end,
 349
 350         TP_PROTO(struct shrinker *shr, int shrinker_retval,
 351                 long unused_scan_cnt, long new_scan_cnt),
 352
 353         TP_ARGS(shr, shrinker_retval, unused_scan_cnt, new_scan_cnt),
 354
 355         TP_FIELDS(
 356                 ctf_integer_hex(struct shrinker *, shr, shr)
 357 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0))
 358                 ctf_integer_hex(void *, shrink, shr->scan_objects)
 359 #else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0)) */
 360                 ctf_integer_hex(void *, shrink, shr->shrink)
 361 #endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0)) */
 362                 ctf_integer(long, unused_scan, unused_scan_cnt)
 363                 ctf_integer(long, new_scan, new_scan_cnt)
 364                 ctf_integer(int, retval, shrinker_retval)
 365                 ctf_integer(long, total_scan, new_scan_cnt - unused_scan_cnt)
 366         )
 367 )
 368 #endif
 369
 370 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,11,0))
 371 LTTNG_TRACEPOINT_EVENT(mm_vmscan_lru_isolate,
 372
 373         TP_PROTO(int classzone_idx,
 374                 int order,
 375                 unsigned long nr_requested,
 376                 unsigned long nr_scanned,
 377                 unsigned long nr_skipped,
 378                 unsigned long nr_taken,
 379                 isolate_mode_t isolate_mode,
 380                 int lru
 381         ),
 382
 383         TP_ARGS(classzone_idx, order, nr_requested, nr_scanned, nr_skipped,
 384                 nr_taken, isolate_mode, lru
 385         ),
 386
 387         TP_FIELDS(
 388                 ctf_integer(int, classzone_idx, classzone_idx)
 389                 ctf_integer(int, order, order)
 390                 ctf_integer(unsigned long, nr_requested, nr_requested)
 391                 ctf_integer(unsigned long, nr_scanned, nr_scanned)
 392                 ctf_integer(unsigned long, nr_skipped, nr_skipped)
 393                 ctf_integer(unsigned long, nr_taken, nr_taken)
 394                 ctf_integer(isolate_mode_t, isolate_mode, isolate_mode)
 395                 ctf_integer(int, lru, lru)
 396         )
 397 )
 398 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,8,0))
 399 LTTNG_TRACEPOINT_EVENT_CLASS(mm_vmscan_lru_isolate_template,
 400
 401         TP_PROTO(int classzone_idx,
 402                 int order,
 403                 unsigned long nr_requested,
 404                 unsigned long nr_scanned,
 405                 unsigned long nr_taken,
 406                 isolate_mode_t isolate_mode,
 407                 int file
 408         ),
 409
 410         TP_ARGS(classzone_idx, order, nr_requested, nr_scanned, nr_taken,
 411                 isolate_mode, file
 412         ),
 413
 414
 415         TP_FIELDS(
 416                 ctf_integer(int, classzone_idx, classzone_idx)
 417                 ctf_integer(int, order, order)
 418                 ctf_integer(unsigned long, nr_requested, nr_requested)
 419                 ctf_integer(unsigned long, nr_scanned, nr_scanned)
 420                 ctf_integer(unsigned long, nr_taken, nr_taken)
 421                 ctf_integer(isolate_mode_t, isolate_mode, isolate_mode)
 422                 ctf_integer(int, file, file)
 423         )
 424 )
 425
 426 LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_lru_isolate_template, mm_vmscan_lru_isolate,
 427
 428         TP_PROTO(int classzone_idx,
 429                 int order,
 430                 unsigned long nr_requested,
 431                 unsigned long nr_scanned,
 432                 unsigned long nr_taken,
 433                 isolate_mode_t isolate_mode,
 434                 int file
 435         ),
 436
 437         TP_ARGS(classzone_idx, order, nr_requested, nr_scanned, nr_taken,
 438                 isolate_mode, file
 439         )
 440
 441 )
 442
 443 LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_lru_isolate_template, mm_vmscan_memcg_isolate,
 444
 445         TP_PROTO(int classzone_idx,
 446                 int order,
 447                 unsigned long nr_requested,
 448                 unsigned long nr_scanned,
 449                 unsigned long nr_taken,
 450                 isolate_mode_t isolate_mode,
 451                 int file
 452         ),
 453
 454         TP_ARGS(classzone_idx, order, nr_requested, nr_scanned, nr_taken,
 455                 isolate_mode, file
 456         )
 457 )
 458 #else
 459 LTTNG_TRACEPOINT_EVENT_CLASS(mm_vmscan_lru_isolate_template,
 460
 461         TP_PROTO(int order,
 462                 unsigned long nr_requested,
 463                 unsigned long nr_scanned,
 464                 unsigned long nr_taken,
 465 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
 466                 unsigned long nr_lumpy_taken,
 467                 unsigned long nr_lumpy_dirty,
 468                 unsigned long nr_lumpy_failed,
 469 #endif
 470 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0))
 471                 isolate_mode_t isolate_mode
 472 #else
 473                 isolate_mode_t isolate_mode,
 474                 int file
 475 #endif
 476         ),
 477
 478         TP_ARGS(order, nr_requested, nr_scanned, nr_taken,
 479 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
 480                 nr_lumpy_taken, nr_lumpy_dirty, nr_lumpy_failed,
 481 #endif
 482 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0))
 483                 isolate_mode
 484 #else
 485                 isolate_mode, file
 486 #endif
 487         ),
 488
 489
 490         TP_FIELDS(
 491                 ctf_integer(int, order, order)
 492                 ctf_integer(unsigned long, nr_requested, nr_requested)
 493                 ctf_integer(unsigned long, nr_scanned, nr_scanned)
 494                 ctf_integer(unsigned long, nr_taken, nr_taken)
 495 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
 496                 ctf_integer(unsigned long, nr_lumpy_taken, nr_lumpy_taken)
 497                 ctf_integer(unsigned long, nr_lumpy_dirty, nr_lumpy_dirty)
 498                 ctf_integer(unsigned long, nr_lumpy_failed, nr_lumpy_failed)
 499 #endif
 500                 ctf_integer(isolate_mode_t, isolate_mode, isolate_mode)
 501 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
 502                 ctf_integer(int, file, file)
 503 #endif
 504         )
 505 )
 506
 507 LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_lru_isolate_template, mm_vmscan_lru_isolate,
 508
 509         TP_PROTO(int order,
 510                 unsigned long nr_requested,
 511                 unsigned long nr_scanned,
 512                 unsigned long nr_taken,
 513 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
 514                 unsigned long nr_lumpy_taken,
 515                 unsigned long nr_lumpy_dirty,
 516                 unsigned long nr_lumpy_failed,
 517 #endif
 518 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0))
 519                 isolate_mode_t isolate_mode
 520 #else
 521                 isolate_mode_t isolate_mode,
 522                 int file
 523 #endif
 524         ),
 525
 526         TP_ARGS(order, nr_requested, nr_scanned, nr_taken,
 527 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
 528                 nr_lumpy_taken, nr_lumpy_dirty, nr_lumpy_failed,
 529 #endif
 530 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0))
 531                 isolate_mode
 532 #else
 533                 isolate_mode, file
 534 #endif
 535         )
 536
 537 )
 538
 539 LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_lru_isolate_template, mm_vmscan_memcg_isolate,
 540
 541         TP_PROTO(int order,
 542                 unsigned long nr_requested,
 543                 unsigned long nr_scanned,
 544                 unsigned long nr_taken,
 545 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
 546                 unsigned long nr_lumpy_taken,
 547                 unsigned long nr_lumpy_dirty,
 548                 unsigned long nr_lumpy_failed,
 549 #endif
 550 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0))
 551                 isolate_mode_t isolate_mode
 552 #else
 553                 isolate_mode_t isolate_mode,
 554                 int file
 555 #endif
 556         ),
 557
 558         TP_ARGS(order, nr_requested, nr_scanned, nr_taken,
 559 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
 560                 nr_lumpy_taken, nr_lumpy_dirty, nr_lumpy_failed,
 561 #endif
 562 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0))
 563                 isolate_mode
 564 #else
 565                 isolate_mode, file
 566 #endif
 567         )
 568 )
 569 #endif
 570
 571 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,2,0))
 572 LTTNG_TRACEPOINT_EVENT(mm_vmscan_writepage,
 573
 574         TP_PROTO(struct page *page),
 575
 576         TP_ARGS(page),
 577
 578         TP_FIELDS(
 579                 ctf_integer_hex(struct page *, page, page)
 580                 ctf_integer(int, reclaim_flags, trace_reclaim_flags(
 581                                 page_is_file_cache(page)))
 582         )
 583 )
 584 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,5,0))
 585 LTTNG_TRACEPOINT_EVENT(mm_vmscan_writepage,
 586
 587         TP_PROTO(struct page *page),
 588
 589         TP_ARGS(page),
 590
 591         TP_FIELDS(
 592                 ctf_integer_hex(struct page *, page, page)
 593                 ctf_integer(int, reclaim_flags, trace_reclaim_flags(page))
 594         )
 595 )
 596 #else
 597 LTTNG_TRACEPOINT_EVENT(mm_vmscan_writepage,
 598
 599         TP_PROTO(struct page *page,
 600                 int reclaim_flags),
 601
 602         TP_ARGS(page, reclaim_flags),
 603
 604         TP_FIELDS(
 605                 ctf_integer_hex(struct page *, page, page)
 606                 ctf_integer(int, reclaim_flags, reclaim_flags)
 607         )
 608 )
 609 #endif
 610
 611 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,2,0))
 612 LTTNG_TRACEPOINT_EVENT(mm_vmscan_lru_shrink_inactive,
 613
 614         TP_PROTO(int nid,
 615                 unsigned long nr_scanned, unsigned long nr_reclaimed,
 616                 struct reclaim_stat *stat, int priority, int file),
 617
 618         TP_ARGS(nid, nr_scanned, nr_reclaimed, stat, priority, file),
 619
 620         TP_FIELDS(
 621                 ctf_integer(int, nid, nid)
 622                 ctf_integer(unsigned long, nr_scanned, nr_scanned)
 623                 ctf_integer(unsigned long, nr_reclaimed, nr_reclaimed)
 624                 ctf_integer(unsigned long, nr_dirty, stat->nr_dirty)
 625                 ctf_integer(unsigned long, nr_writeback, stat->nr_writeback)
 626                 ctf_integer(unsigned long, nr_congested, stat->nr_congested)
 627                 ctf_integer(unsigned long, nr_immediate, stat->nr_immediate)
 628                 ctf_integer(unsigned long, nr_activate_anon, stat->nr_activate[0])
 629                 ctf_integer(unsigned long, nr_activate_file, stat->nr_activate[1])
 630                 ctf_integer(unsigned long, nr_ref_keep, stat->nr_ref_keep)
 631                 ctf_integer(unsigned long, nr_unmap_fail, stat->nr_unmap_fail)
 632                 ctf_integer(int, priority, priority)
 633                 ctf_integer(int, reclaim_flags, trace_reclaim_flags(file))
 634         )
 635 )
 636 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,17,0))
 637 LTTNG_TRACEPOINT_EVENT(mm_vmscan_lru_shrink_inactive,
 638
 639         TP_PROTO(int nid,
 640                 unsigned long nr_scanned, unsigned long nr_reclaimed,
 641                 struct reclaim_stat *stat, int priority, int file),
 642
 643         TP_ARGS(nid, nr_scanned, nr_reclaimed, stat, priority, file),
 644
 645         TP_FIELDS(
 646                 ctf_integer(int, nid, nid)
 647                 ctf_integer(unsigned long, nr_scanned, nr_scanned)
 648                 ctf_integer(unsigned long, nr_reclaimed, nr_reclaimed)
 649                 ctf_integer(unsigned long, nr_dirty, stat->nr_dirty)
 650                 ctf_integer(unsigned long, nr_writeback, stat->nr_writeback)
 651                 ctf_integer(unsigned long, nr_congested, stat->nr_congested)
 652                 ctf_integer(unsigned long, nr_immediate, stat->nr_immediate)
 653                 ctf_integer(unsigned long, nr_activate, stat->nr_activate)
 654                 ctf_integer(unsigned long, nr_ref_keep, stat->nr_ref_keep)
 655                 ctf_integer(unsigned long, nr_unmap_fail, stat->nr_unmap_fail)
 656                 ctf_integer(int, priority, priority)
 657                 ctf_integer(int, reclaim_flags, trace_shrink_flags(file))
 658         )
 659 )
 660 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,11,0))
 661 LTTNG_TRACEPOINT_EVENT(mm_vmscan_lru_shrink_inactive,
 662
 663         TP_PROTO(int nid,
 664                 unsigned long nr_scanned, unsigned long nr_reclaimed,
 665                 unsigned long nr_dirty, unsigned long nr_writeback,
 666                 unsigned long nr_congested, unsigned long nr_immediate,
 667                 unsigned long nr_activate, unsigned long nr_ref_keep,
 668                 unsigned long nr_unmap_fail,
 669                 int priority, int file),
 670
 671         TP_ARGS(nid, nr_scanned, nr_reclaimed, nr_dirty, nr_writeback,
 672                 nr_congested, nr_immediate, nr_activate, nr_ref_keep,
 673                 nr_unmap_fail, priority, file),
 674
 675         TP_FIELDS(
 676                 ctf_integer(int, nid, nid)
 677                 ctf_integer(unsigned long, nr_scanned, nr_scanned)
 678                 ctf_integer(unsigned long, nr_reclaimed, nr_reclaimed)
 679                 ctf_integer(unsigned long, nr_dirty, nr_dirty)
 680                 ctf_integer(unsigned long, nr_writeback, nr_writeback)
 681                 ctf_integer(unsigned long, nr_congested, nr_congested)
 682                 ctf_integer(unsigned long, nr_immediate, nr_immediate)
 683                 ctf_integer(unsigned long, nr_activate, nr_activate)
 684                 ctf_integer(unsigned long, nr_ref_keep, nr_ref_keep)
 685                 ctf_integer(unsigned long, nr_unmap_fail, nr_unmap_fail)
 686                 ctf_integer(int, priority, priority)
 687                 ctf_integer(int, reclaim_flags, trace_shrink_flags(file))
 688         )
 689 )
 690 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,8,0))
 691 LTTNG_TRACEPOINT_EVENT(mm_vmscan_lru_shrink_inactive,
 692
 693         TP_PROTO(int nid,
 694                 unsigned long nr_scanned, unsigned long nr_reclaimed,
 695                 int priority, int file),
 696
 697         TP_ARGS(nid, nr_scanned, nr_reclaimed, priority, file),
 698
 699         TP_FIELDS(
 700                 ctf_integer(int, nid, nid)
 701                 ctf_integer(unsigned long, nr_scanned, nr_scanned)
 702                 ctf_integer(unsigned long, nr_reclaimed, nr_reclaimed)
 703                 ctf_integer(int, priority, priority)
 704                 ctf_integer(int, reclaim_flags, trace_shrink_flags(file))
 705         )
 706 )
 707 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,5,0))
 708 LTTNG_TRACEPOINT_EVENT(mm_vmscan_lru_shrink_inactive,
 709
 710         TP_PROTO(struct zone *zone,
 711                 unsigned long nr_scanned, unsigned long nr_reclaimed,
 712                 int priority, int file),
 713
 714         TP_ARGS(zone, nr_scanned, nr_reclaimed, priority, file),
 715
 716         TP_FIELDS(
 717                 ctf_integer(int, nid, zone_to_nid(zone))
 718                 ctf_integer(int, zid, zone_idx(zone))
 719                 ctf_integer(unsigned long, nr_scanned, nr_scanned)
 720                 ctf_integer(unsigned long, nr_reclaimed, nr_reclaimed)
 721                 ctf_integer(int, priority, priority)
 722                 ctf_integer(int, reclaim_flags, trace_shrink_flags(file))
 723         )
 724 )
 725 #else
 726 LTTNG_TRACEPOINT_EVENT(mm_vmscan_lru_shrink_inactive,
 727
 728         TP_PROTO(int nid, int zid,
 729                         unsigned long nr_scanned, unsigned long nr_reclaimed,
 730                         int priority, int reclaim_flags),
 731
 732         TP_ARGS(nid, zid, nr_scanned, nr_reclaimed, priority, reclaim_flags),
 733
 734         TP_FIELDS(
 735                 ctf_integer(int, nid, nid)
 736                 ctf_integer(int, zid, zid)
 737                 ctf_integer(unsigned long, nr_scanned, nr_scanned)
 738                 ctf_integer(unsigned long, nr_reclaimed, nr_reclaimed)
 739                 ctf_integer(int, priority, priority)
 740                 ctf_integer(int, reclaim_flags, reclaim_flags)
 741         )
 742 )
 743 #endif
 744
 745 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
 746 LTTNG_TRACEPOINT_EVENT_MAP(replace_swap_token,
 747
 748         mm_vmscan_replace_swap_token,
 749
 750         TP_PROTO(struct mm_struct *old_mm,
 751                  struct mm_struct *new_mm),
 752
 753         TP_ARGS(old_mm, new_mm),
 754
 755         TP_FIELDS(
 756                 ctf_integer_hex(struct mm_struct *, old_mm, old_mm)
 757                 ctf_integer(unsigned int, old_prio, old_mm ? old_mm->token_priority : 0)
 758                 ctf_integer_hex(struct mm_struct *, new_mm, new_mm)
 759                 ctf_integer(unsigned int, new_prio, new_mm->token_priority)
 760         )
 761 )
 762
 763 LTTNG_TRACEPOINT_EVENT_CLASS(mm_vmscan_put_swap_token_template,
 764         TP_PROTO(struct mm_struct *swap_token_mm),
 765
 766         TP_ARGS(swap_token_mm),
 767
 768         TP_FIELDS(
 769                 ctf_integer_hex(struct mm_struct*, swap_token_mm, swap_token_mm)
 770         )
 771 )
 772
 773 LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(mm_vmscan_put_swap_token_template, put_swap_token,
 774
 775         mm_vmscan_put_swap_token,
 776
 777         TP_PROTO(struct mm_struct *swap_token_mm),
 778         TP_ARGS(swap_token_mm)
 779 )
 780
 781 LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(mm_vmscan_put_swap_token_template, disable_swap_token,
 782
 783         mm_vmscan_disable_swap_token,
 784
 785         TP_PROTO(struct mm_struct *swap_token_mm),
 786         TP_ARGS(swap_token_mm)
 787 )
 788
 789 LTTNG_TRACEPOINT_EVENT_MAP(update_swap_token_priority,
 790
 791         mm_vmscan_update_swap_token_priority,
 792
 793         TP_PROTO(struct mm_struct *mm,
 794                  unsigned int old_prio,
 795                  struct mm_struct *swap_token_mm),
 796
 797         TP_ARGS(mm, old_prio, swap_token_mm),
 798
 799         TP_FIELDS(
 800                 ctf_integer_hex(struct mm_struct *, mm, mm)
 801                 ctf_integer(unsigned int, old_prio, old_prio)
 802                 ctf_integer(unsigned int, new_prio, mm->token_priority)
 803                 ctf_integer_hex(struct mm_struct *, swap_token_mm, swap_token_mm)
 804                 ctf_integer(unsigned int, swap_token_prio, swap_token_mm ? swap_token_mm->token_priority : 0)
 805         )
 806 )
 807 #endif
 808
 809 #endif /* LTTNG_TRACE_MM_VMSCAN_H */
 810
 811 /* This part must be outside protection */
 812 #include <probes/define_trace.h>