Back to home page

OSCL-LXR
 
 

     

0001 /* SPDX-License-Identifier: GPL-2.0 */
0002 #undef TRACE_SYSTEM
0003 #define TRACE_SYSTEM vmscan
0004 
0005 #if !defined(_TRACE_VMSCAN_H) || defined(TRACE_HEADER_MULTI_READ)
0006 #define _TRACE_VMSCAN_H
0007 
0008 #include <linux/types.h>
0009 #include <linux/tracepoint.h>
0010 #include <linux/mm.h>
0011 #include <linux/memcontrol.h>
0012 #include <trace/events/mmflags.h>
0013 
0014 #define RECLAIM_WB_ANON     0x0001u
0015 #define RECLAIM_WB_FILE     0x0002u
0016 #define RECLAIM_WB_MIXED    0x0010u
0017 #define RECLAIM_WB_SYNC     0x0004u /* Unused, all reclaim async */
0018 #define RECLAIM_WB_ASYNC    0x0008u
0019 #define RECLAIM_WB_LRU      (RECLAIM_WB_ANON|RECLAIM_WB_FILE)
0020 
0021 #define show_reclaim_flags(flags)               \
0022     (flags) ? __print_flags(flags, "|",         \
0023         {RECLAIM_WB_ANON,   "RECLAIM_WB_ANON"}, \
0024         {RECLAIM_WB_FILE,   "RECLAIM_WB_FILE"}, \
0025         {RECLAIM_WB_MIXED,  "RECLAIM_WB_MIXED"},    \
0026         {RECLAIM_WB_SYNC,   "RECLAIM_WB_SYNC"}, \
0027         {RECLAIM_WB_ASYNC,  "RECLAIM_WB_ASYNC"} \
0028         ) : "RECLAIM_WB_NONE"
0029 
0030 #define _VMSCAN_THROTTLE_WRITEBACK  (1 << VMSCAN_THROTTLE_WRITEBACK)
0031 #define _VMSCAN_THROTTLE_ISOLATED   (1 << VMSCAN_THROTTLE_ISOLATED)
0032 #define _VMSCAN_THROTTLE_NOPROGRESS (1 << VMSCAN_THROTTLE_NOPROGRESS)
0033 #define _VMSCAN_THROTTLE_CONGESTED  (1 << VMSCAN_THROTTLE_CONGESTED)
0034 
0035 #define show_throttle_flags(flags)                      \
0036     (flags) ? __print_flags(flags, "|",                 \
0037         {_VMSCAN_THROTTLE_WRITEBACK,    "VMSCAN_THROTTLE_WRITEBACK"},   \
0038         {_VMSCAN_THROTTLE_ISOLATED, "VMSCAN_THROTTLE_ISOLATED"},    \
0039         {_VMSCAN_THROTTLE_NOPROGRESS,   "VMSCAN_THROTTLE_NOPROGRESS"},  \
0040         {_VMSCAN_THROTTLE_CONGESTED,    "VMSCAN_THROTTLE_CONGESTED"}    \
0041         ) : "VMSCAN_THROTTLE_NONE"
0042 
0043 
0044 #define trace_reclaim_flags(file) ( \
0045     (file ? RECLAIM_WB_FILE : RECLAIM_WB_ANON) | \
0046     (RECLAIM_WB_ASYNC) \
0047     )
0048 
0049 TRACE_EVENT(mm_vmscan_kswapd_sleep,
0050 
0051     TP_PROTO(int nid),
0052 
0053     TP_ARGS(nid),
0054 
0055     TP_STRUCT__entry(
0056         __field(    int,    nid )
0057     ),
0058 
0059     TP_fast_assign(
0060         __entry->nid    = nid;
0061     ),
0062 
0063     TP_printk("nid=%d", __entry->nid)
0064 );
0065 
0066 TRACE_EVENT(mm_vmscan_kswapd_wake,
0067 
0068     TP_PROTO(int nid, int zid, int order),
0069 
0070     TP_ARGS(nid, zid, order),
0071 
0072     TP_STRUCT__entry(
0073         __field(    int,    nid )
0074         __field(    int,    zid )
0075         __field(    int,    order   )
0076     ),
0077 
0078     TP_fast_assign(
0079         __entry->nid    = nid;
0080         __entry->zid    = zid;
0081         __entry->order  = order;
0082     ),
0083 
0084     TP_printk("nid=%d order=%d",
0085         __entry->nid,
0086         __entry->order)
0087 );
0088 
0089 TRACE_EVENT(mm_vmscan_wakeup_kswapd,
0090 
0091     TP_PROTO(int nid, int zid, int order, gfp_t gfp_flags),
0092 
0093     TP_ARGS(nid, zid, order, gfp_flags),
0094 
0095     TP_STRUCT__entry(
0096         __field(    int,    nid     )
0097         __field(    int,    zid     )
0098         __field(    int,    order       )
0099         __field(    unsigned long,  gfp_flags   )
0100     ),
0101 
0102     TP_fast_assign(
0103         __entry->nid        = nid;
0104         __entry->zid        = zid;
0105         __entry->order      = order;
0106         __entry->gfp_flags  = (__force unsigned long)gfp_flags;
0107     ),
0108 
0109     TP_printk("nid=%d order=%d gfp_flags=%s",
0110         __entry->nid,
0111         __entry->order,
0112         show_gfp_flags(__entry->gfp_flags))
0113 );
0114 
0115 DECLARE_EVENT_CLASS(mm_vmscan_direct_reclaim_begin_template,
0116 
0117     TP_PROTO(int order, gfp_t gfp_flags),
0118 
0119     TP_ARGS(order, gfp_flags),
0120 
0121     TP_STRUCT__entry(
0122         __field(    int,    order       )
0123         __field(    unsigned long,  gfp_flags   )
0124     ),
0125 
0126     TP_fast_assign(
0127         __entry->order      = order;
0128         __entry->gfp_flags  = (__force unsigned long)gfp_flags;
0129     ),
0130 
0131     TP_printk("order=%d gfp_flags=%s",
0132         __entry->order,
0133         show_gfp_flags(__entry->gfp_flags))
0134 );
0135 
0136 DEFINE_EVENT(mm_vmscan_direct_reclaim_begin_template, mm_vmscan_direct_reclaim_begin,
0137 
0138     TP_PROTO(int order, gfp_t gfp_flags),
0139 
0140     TP_ARGS(order, gfp_flags)
0141 );
0142 
0143 #ifdef CONFIG_MEMCG
0144 DEFINE_EVENT(mm_vmscan_direct_reclaim_begin_template, mm_vmscan_memcg_reclaim_begin,
0145 
0146     TP_PROTO(int order, gfp_t gfp_flags),
0147 
0148     TP_ARGS(order, gfp_flags)
0149 );
0150 
0151 DEFINE_EVENT(mm_vmscan_direct_reclaim_begin_template, mm_vmscan_memcg_softlimit_reclaim_begin,
0152 
0153     TP_PROTO(int order, gfp_t gfp_flags),
0154 
0155     TP_ARGS(order, gfp_flags)
0156 );
0157 #endif /* CONFIG_MEMCG */
0158 
0159 DECLARE_EVENT_CLASS(mm_vmscan_direct_reclaim_end_template,
0160 
0161     TP_PROTO(unsigned long nr_reclaimed),
0162 
0163     TP_ARGS(nr_reclaimed),
0164 
0165     TP_STRUCT__entry(
0166         __field(    unsigned long,  nr_reclaimed    )
0167     ),
0168 
0169     TP_fast_assign(
0170         __entry->nr_reclaimed   = nr_reclaimed;
0171     ),
0172 
0173     TP_printk("nr_reclaimed=%lu", __entry->nr_reclaimed)
0174 );
0175 
0176 DEFINE_EVENT(mm_vmscan_direct_reclaim_end_template, mm_vmscan_direct_reclaim_end,
0177 
0178     TP_PROTO(unsigned long nr_reclaimed),
0179 
0180     TP_ARGS(nr_reclaimed)
0181 );
0182 
0183 #ifdef CONFIG_MEMCG
0184 DEFINE_EVENT(mm_vmscan_direct_reclaim_end_template, mm_vmscan_memcg_reclaim_end,
0185 
0186     TP_PROTO(unsigned long nr_reclaimed),
0187 
0188     TP_ARGS(nr_reclaimed)
0189 );
0190 
0191 DEFINE_EVENT(mm_vmscan_direct_reclaim_end_template, mm_vmscan_memcg_softlimit_reclaim_end,
0192 
0193     TP_PROTO(unsigned long nr_reclaimed),
0194 
0195     TP_ARGS(nr_reclaimed)
0196 );
0197 #endif /* CONFIG_MEMCG */
0198 
0199 TRACE_EVENT(mm_shrink_slab_start,
0200     TP_PROTO(struct shrinker *shr, struct shrink_control *sc,
0201         long nr_objects_to_shrink, unsigned long cache_items,
0202         unsigned long long delta, unsigned long total_scan,
0203         int priority),
0204 
0205     TP_ARGS(shr, sc, nr_objects_to_shrink, cache_items, delta, total_scan,
0206         priority),
0207 
0208     TP_STRUCT__entry(
0209         __field(struct shrinker *, shr)
0210         __field(void *, shrink)
0211         __field(int, nid)
0212         __field(long, nr_objects_to_shrink)
0213         __field(unsigned long, gfp_flags)
0214         __field(unsigned long, cache_items)
0215         __field(unsigned long long, delta)
0216         __field(unsigned long, total_scan)
0217         __field(int, priority)
0218     ),
0219 
0220     TP_fast_assign(
0221         __entry->shr = shr;
0222         __entry->shrink = shr->scan_objects;
0223         __entry->nid = sc->nid;
0224         __entry->nr_objects_to_shrink = nr_objects_to_shrink;
0225         __entry->gfp_flags = (__force unsigned long)sc->gfp_mask;
0226         __entry->cache_items = cache_items;
0227         __entry->delta = delta;
0228         __entry->total_scan = total_scan;
0229         __entry->priority = priority;
0230     ),
0231 
0232     TP_printk("%pS %p: nid: %d objects to shrink %ld gfp_flags %s cache items %ld delta %lld total_scan %ld priority %d",
0233         __entry->shrink,
0234         __entry->shr,
0235         __entry->nid,
0236         __entry->nr_objects_to_shrink,
0237         show_gfp_flags(__entry->gfp_flags),
0238         __entry->cache_items,
0239         __entry->delta,
0240         __entry->total_scan,
0241         __entry->priority)
0242 );
0243 
0244 TRACE_EVENT(mm_shrink_slab_end,
0245     TP_PROTO(struct shrinker *shr, int nid, int shrinker_retval,
0246         long unused_scan_cnt, long new_scan_cnt, long total_scan),
0247 
0248     TP_ARGS(shr, nid, shrinker_retval, unused_scan_cnt, new_scan_cnt,
0249         total_scan),
0250 
0251     TP_STRUCT__entry(
0252         __field(struct shrinker *, shr)
0253         __field(int, nid)
0254         __field(void *, shrink)
0255         __field(long, unused_scan)
0256         __field(long, new_scan)
0257         __field(int, retval)
0258         __field(long, total_scan)
0259     ),
0260 
0261     TP_fast_assign(
0262         __entry->shr = shr;
0263         __entry->nid = nid;
0264         __entry->shrink = shr->scan_objects;
0265         __entry->unused_scan = unused_scan_cnt;
0266         __entry->new_scan = new_scan_cnt;
0267         __entry->retval = shrinker_retval;
0268         __entry->total_scan = total_scan;
0269     ),
0270 
0271     TP_printk("%pS %p: nid: %d unused scan count %ld new scan count %ld total_scan %ld last shrinker return val %d",
0272         __entry->shrink,
0273         __entry->shr,
0274         __entry->nid,
0275         __entry->unused_scan,
0276         __entry->new_scan,
0277         __entry->total_scan,
0278         __entry->retval)
0279 );
0280 
0281 TRACE_EVENT(mm_vmscan_lru_isolate,
0282     TP_PROTO(int highest_zoneidx,
0283         int order,
0284         unsigned long nr_requested,
0285         unsigned long nr_scanned,
0286         unsigned long nr_skipped,
0287         unsigned long nr_taken,
0288         isolate_mode_t isolate_mode,
0289         int lru),
0290 
0291     TP_ARGS(highest_zoneidx, order, nr_requested, nr_scanned, nr_skipped, nr_taken, isolate_mode, lru),
0292 
0293     TP_STRUCT__entry(
0294         __field(int, highest_zoneidx)
0295         __field(int, order)
0296         __field(unsigned long, nr_requested)
0297         __field(unsigned long, nr_scanned)
0298         __field(unsigned long, nr_skipped)
0299         __field(unsigned long, nr_taken)
0300         __field(unsigned int, isolate_mode)
0301         __field(int, lru)
0302     ),
0303 
0304     TP_fast_assign(
0305         __entry->highest_zoneidx = highest_zoneidx;
0306         __entry->order = order;
0307         __entry->nr_requested = nr_requested;
0308         __entry->nr_scanned = nr_scanned;
0309         __entry->nr_skipped = nr_skipped;
0310         __entry->nr_taken = nr_taken;
0311         __entry->isolate_mode = (__force unsigned int)isolate_mode;
0312         __entry->lru = lru;
0313     ),
0314 
0315     /*
0316      * classzone is previous name of the highest_zoneidx.
0317      * Reason not to change it is the ABI requirement of the tracepoint.
0318      */
0319     TP_printk("isolate_mode=%d classzone=%d order=%d nr_requested=%lu nr_scanned=%lu nr_skipped=%lu nr_taken=%lu lru=%s",
0320         __entry->isolate_mode,
0321         __entry->highest_zoneidx,
0322         __entry->order,
0323         __entry->nr_requested,
0324         __entry->nr_scanned,
0325         __entry->nr_skipped,
0326         __entry->nr_taken,
0327         __print_symbolic(__entry->lru, LRU_NAMES))
0328 );
0329 
0330 TRACE_EVENT(mm_vmscan_write_folio,
0331 
0332     TP_PROTO(struct folio *folio),
0333 
0334     TP_ARGS(folio),
0335 
0336     TP_STRUCT__entry(
0337         __field(unsigned long, pfn)
0338         __field(int, reclaim_flags)
0339     ),
0340 
0341     TP_fast_assign(
0342         __entry->pfn = folio_pfn(folio);
0343         __entry->reclaim_flags = trace_reclaim_flags(
0344                         folio_is_file_lru(folio));
0345     ),
0346 
0347     TP_printk("page=%p pfn=0x%lx flags=%s",
0348         pfn_to_page(__entry->pfn),
0349         __entry->pfn,
0350         show_reclaim_flags(__entry->reclaim_flags))
0351 );
0352 
0353 TRACE_EVENT(mm_vmscan_lru_shrink_inactive,
0354 
0355     TP_PROTO(int nid,
0356         unsigned long nr_scanned, unsigned long nr_reclaimed,
0357         struct reclaim_stat *stat, int priority, int file),
0358 
0359     TP_ARGS(nid, nr_scanned, nr_reclaimed, stat, priority, file),
0360 
0361     TP_STRUCT__entry(
0362         __field(int, nid)
0363         __field(unsigned long, nr_scanned)
0364         __field(unsigned long, nr_reclaimed)
0365         __field(unsigned long, nr_dirty)
0366         __field(unsigned long, nr_writeback)
0367         __field(unsigned long, nr_congested)
0368         __field(unsigned long, nr_immediate)
0369         __field(unsigned int, nr_activate0)
0370         __field(unsigned int, nr_activate1)
0371         __field(unsigned long, nr_ref_keep)
0372         __field(unsigned long, nr_unmap_fail)
0373         __field(int, priority)
0374         __field(int, reclaim_flags)
0375     ),
0376 
0377     TP_fast_assign(
0378         __entry->nid = nid;
0379         __entry->nr_scanned = nr_scanned;
0380         __entry->nr_reclaimed = nr_reclaimed;
0381         __entry->nr_dirty = stat->nr_dirty;
0382         __entry->nr_writeback = stat->nr_writeback;
0383         __entry->nr_congested = stat->nr_congested;
0384         __entry->nr_immediate = stat->nr_immediate;
0385         __entry->nr_activate0 = stat->nr_activate[0];
0386         __entry->nr_activate1 = stat->nr_activate[1];
0387         __entry->nr_ref_keep = stat->nr_ref_keep;
0388         __entry->nr_unmap_fail = stat->nr_unmap_fail;
0389         __entry->priority = priority;
0390         __entry->reclaim_flags = trace_reclaim_flags(file);
0391     ),
0392 
0393     TP_printk("nid=%d nr_scanned=%ld nr_reclaimed=%ld nr_dirty=%ld nr_writeback=%ld nr_congested=%ld nr_immediate=%ld nr_activate_anon=%d nr_activate_file=%d nr_ref_keep=%ld nr_unmap_fail=%ld priority=%d flags=%s",
0394         __entry->nid,
0395         __entry->nr_scanned, __entry->nr_reclaimed,
0396         __entry->nr_dirty, __entry->nr_writeback,
0397         __entry->nr_congested, __entry->nr_immediate,
0398         __entry->nr_activate0, __entry->nr_activate1,
0399         __entry->nr_ref_keep, __entry->nr_unmap_fail,
0400         __entry->priority,
0401         show_reclaim_flags(__entry->reclaim_flags))
0402 );
0403 
0404 TRACE_EVENT(mm_vmscan_lru_shrink_active,
0405 
0406     TP_PROTO(int nid, unsigned long nr_taken,
0407         unsigned long nr_active, unsigned long nr_deactivated,
0408         unsigned long nr_referenced, int priority, int file),
0409 
0410     TP_ARGS(nid, nr_taken, nr_active, nr_deactivated, nr_referenced, priority, file),
0411 
0412     TP_STRUCT__entry(
0413         __field(int, nid)
0414         __field(unsigned long, nr_taken)
0415         __field(unsigned long, nr_active)
0416         __field(unsigned long, nr_deactivated)
0417         __field(unsigned long, nr_referenced)
0418         __field(int, priority)
0419         __field(int, reclaim_flags)
0420     ),
0421 
0422     TP_fast_assign(
0423         __entry->nid = nid;
0424         __entry->nr_taken = nr_taken;
0425         __entry->nr_active = nr_active;
0426         __entry->nr_deactivated = nr_deactivated;
0427         __entry->nr_referenced = nr_referenced;
0428         __entry->priority = priority;
0429         __entry->reclaim_flags = trace_reclaim_flags(file);
0430     ),
0431 
0432     TP_printk("nid=%d nr_taken=%ld nr_active=%ld nr_deactivated=%ld nr_referenced=%ld priority=%d flags=%s",
0433         __entry->nid,
0434         __entry->nr_taken,
0435         __entry->nr_active, __entry->nr_deactivated, __entry->nr_referenced,
0436         __entry->priority,
0437         show_reclaim_flags(__entry->reclaim_flags))
0438 );
0439 
0440 TRACE_EVENT(mm_vmscan_node_reclaim_begin,
0441 
0442     TP_PROTO(int nid, int order, gfp_t gfp_flags),
0443 
0444     TP_ARGS(nid, order, gfp_flags),
0445 
0446     TP_STRUCT__entry(
0447         __field(int, nid)
0448         __field(int, order)
0449         __field(unsigned long, gfp_flags)
0450     ),
0451 
0452     TP_fast_assign(
0453         __entry->nid = nid;
0454         __entry->order = order;
0455         __entry->gfp_flags = (__force unsigned long)gfp_flags;
0456     ),
0457 
0458     TP_printk("nid=%d order=%d gfp_flags=%s",
0459         __entry->nid,
0460         __entry->order,
0461         show_gfp_flags(__entry->gfp_flags))
0462 );
0463 
0464 DEFINE_EVENT(mm_vmscan_direct_reclaim_end_template, mm_vmscan_node_reclaim_end,
0465 
0466     TP_PROTO(unsigned long nr_reclaimed),
0467 
0468     TP_ARGS(nr_reclaimed)
0469 );
0470 
0471 TRACE_EVENT(mm_vmscan_throttled,
0472 
0473     TP_PROTO(int nid, int usec_timeout, int usec_delayed, int reason),
0474 
0475     TP_ARGS(nid, usec_timeout, usec_delayed, reason),
0476 
0477     TP_STRUCT__entry(
0478         __field(int, nid)
0479         __field(int, usec_timeout)
0480         __field(int, usec_delayed)
0481         __field(int, reason)
0482     ),
0483 
0484     TP_fast_assign(
0485         __entry->nid = nid;
0486         __entry->usec_timeout = usec_timeout;
0487         __entry->usec_delayed = usec_delayed;
0488         __entry->reason = 1U << reason;
0489     ),
0490 
0491     TP_printk("nid=%d usec_timeout=%d usect_delayed=%d reason=%s",
0492         __entry->nid,
0493         __entry->usec_timeout,
0494         __entry->usec_delayed,
0495         show_throttle_flags(__entry->reason))
0496 );
0497 #endif /* _TRACE_VMSCAN_H */
0498 
0499 /* This part must be outside protection */
0500 #include <trace/define_trace.h>
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!