Back to home page

OSCL-LXR
 
 

     

0001 /* SPDX-License-Identifier: GPL-2.0 */
0002 #undef TRACE_SYSTEM
0003 #define TRACE_SYSTEM gfs2
0004 
0005 #if !defined(_TRACE_GFS2_H) || defined(TRACE_HEADER_MULTI_READ)
0006 #define _TRACE_GFS2_H
0007 
0008 #include <linux/tracepoint.h>
0009 
0010 #include <linux/fs.h>
0011 #include <linux/buffer_head.h>
0012 #include <linux/dlmconstants.h>
0013 #include <linux/gfs2_ondisk.h>
0014 #include <linux/writeback.h>
0015 #include <linux/ktime.h>
0016 #include <linux/iomap.h>
0017 #include "incore.h"
0018 #include "glock.h"
0019 #include "rgrp.h"
0020 
0021 #define dlm_state_name(nn) { DLM_LOCK_##nn, #nn }
0022 #define glock_trace_name(x) __print_symbolic(x,     \
0023                 dlm_state_name(IV),     \
0024                 dlm_state_name(NL),     \
0025                 dlm_state_name(CR),     \
0026                 dlm_state_name(CW),     \
0027                 dlm_state_name(PR),     \
0028                 dlm_state_name(PW),     \
0029                 dlm_state_name(EX))
0030 
0031 #define block_state_name(x) __print_symbolic(x,         \
0032                 { GFS2_BLKST_FREE, "free" },    \
0033                 { GFS2_BLKST_USED, "used" },    \
0034                 { GFS2_BLKST_DINODE, "dinode" },    \
0035                 { GFS2_BLKST_UNLINKED, "unlinked" })
0036 
0037 #define TRACE_RS_DELETE  0
0038 #define TRACE_RS_TREEDEL 1
0039 #define TRACE_RS_INSERT  2
0040 #define TRACE_RS_CLAIM   3
0041 
0042 #define rs_func_name(x) __print_symbolic(x, \
0043                      { 0, "del " }, \
0044                      { 1, "tdel" }, \
0045                      { 2, "ins " }, \
0046                      { 3, "clm " })
0047 
0048 #define show_glock_flags(flags) __print_flags(flags, "",    \
0049     {(1UL << GLF_LOCK),         "l" },      \
0050     {(1UL << GLF_DEMOTE),           "D" },      \
0051     {(1UL << GLF_PENDING_DEMOTE),       "d" },      \
0052     {(1UL << GLF_DEMOTE_IN_PROGRESS),   "p" },      \
0053     {(1UL << GLF_DIRTY),            "y" },      \
0054     {(1UL << GLF_LFLUSH),           "f" },      \
0055     {(1UL << GLF_INVALIDATE_IN_PROGRESS),   "i" },      \
0056     {(1UL << GLF_REPLY_PENDING),        "r" },      \
0057     {(1UL << GLF_INITIAL),          "I" },      \
0058     {(1UL << GLF_FROZEN),           "F" },      \
0059     {(1UL << GLF_LRU),          "L" },      \
0060     {(1UL << GLF_OBJECT),           "o" },      \
0061     {(1UL << GLF_BLOCKING),         "b" })
0062 
0063 #ifndef NUMPTY
0064 #define NUMPTY
0065 static inline u8 glock_trace_state(unsigned int state)
0066 {
0067     switch(state) {
0068     case LM_ST_SHARED:
0069         return DLM_LOCK_PR;
0070     case LM_ST_DEFERRED:
0071         return DLM_LOCK_CW;
0072     case LM_ST_EXCLUSIVE:
0073         return DLM_LOCK_EX;
0074     }
0075     return DLM_LOCK_NL;
0076 }
0077 #endif
0078 
0079 /* Section 1 - Locking
0080  *
0081  * Objectives:
0082  * Latency: Remote demote request to state change
0083  * Latency: Local lock request to state change
0084  * Latency: State change to lock grant
0085  * Correctness: Ordering of local lock state vs. I/O requests
0086  * Correctness: Responses to remote demote requests
0087  */
0088 
0089 /* General glock state change (DLM lock request completes) */
0090 TRACE_EVENT(gfs2_glock_state_change,
0091 
0092     TP_PROTO(const struct gfs2_glock *gl, unsigned int new_state),
0093 
0094     TP_ARGS(gl, new_state),
0095 
0096     TP_STRUCT__entry(
0097         __field(    dev_t,  dev         )
0098         __field(    u64,    glnum           )
0099         __field(    u32,    gltype          )
0100         __field(    u8, cur_state       )
0101         __field(    u8, new_state       )
0102         __field(    u8, dmt_state       )
0103         __field(    u8, tgt_state       )
0104         __field(    unsigned long,  flags       )
0105     ),
0106 
0107     TP_fast_assign(
0108         __entry->dev        = gl->gl_name.ln_sbd->sd_vfs->s_dev;
0109         __entry->glnum      = gl->gl_name.ln_number;
0110         __entry->gltype     = gl->gl_name.ln_type;
0111         __entry->cur_state  = glock_trace_state(gl->gl_state);
0112         __entry->new_state  = glock_trace_state(new_state);
0113         __entry->tgt_state  = glock_trace_state(gl->gl_target);
0114         __entry->dmt_state  = glock_trace_state(gl->gl_demote_state);
0115         __entry->flags      = gl->gl_flags | (gl->gl_object ? (1UL<<GLF_OBJECT) : 0);
0116     ),
0117 
0118     TP_printk("%u,%u glock %d:%lld state %s to %s tgt:%s dmt:%s flags:%s",
0119           MAJOR(__entry->dev), MINOR(__entry->dev), __entry->gltype,
0120          (unsigned long long)__entry->glnum,
0121           glock_trace_name(__entry->cur_state),
0122           glock_trace_name(__entry->new_state),
0123           glock_trace_name(__entry->tgt_state),
0124           glock_trace_name(__entry->dmt_state),
0125           show_glock_flags(__entry->flags))
0126 );
0127 
0128 /* State change -> unlocked, glock is being deallocated */
0129 TRACE_EVENT(gfs2_glock_put,
0130 
0131     TP_PROTO(const struct gfs2_glock *gl),
0132 
0133     TP_ARGS(gl),
0134 
0135     TP_STRUCT__entry(
0136         __field(        dev_t,  dev                     )
0137         __field(    u64,    glnum           )
0138         __field(    u32,    gltype          )
0139         __field(    u8, cur_state       )
0140         __field(    unsigned long,  flags       )
0141     ),
0142 
0143     TP_fast_assign(
0144         __entry->dev        = gl->gl_name.ln_sbd->sd_vfs->s_dev;
0145         __entry->gltype     = gl->gl_name.ln_type;
0146         __entry->glnum      = gl->gl_name.ln_number;
0147         __entry->cur_state  = glock_trace_state(gl->gl_state);
0148         __entry->flags      = gl->gl_flags  | (gl->gl_object ? (1UL<<GLF_OBJECT) : 0);
0149     ),
0150 
0151     TP_printk("%u,%u glock %d:%lld state %s => %s flags:%s",
0152           MAJOR(__entry->dev), MINOR(__entry->dev),
0153                   __entry->gltype, (unsigned long long)__entry->glnum,
0154                   glock_trace_name(__entry->cur_state),
0155           glock_trace_name(DLM_LOCK_IV),
0156           show_glock_flags(__entry->flags))
0157 
0158 );
0159 
0160 /* Callback (local or remote) requesting lock demotion */
0161 TRACE_EVENT(gfs2_demote_rq,
0162 
0163     TP_PROTO(const struct gfs2_glock *gl, bool remote),
0164 
0165     TP_ARGS(gl, remote),
0166 
0167     TP_STRUCT__entry(
0168         __field(        dev_t,  dev                     )
0169         __field(    u64,    glnum           )
0170         __field(    u32,    gltype          )
0171         __field(    u8, cur_state       )
0172         __field(    u8, dmt_state       )
0173         __field(    unsigned long,  flags       )
0174         __field(    bool,   remote          )
0175     ),
0176 
0177     TP_fast_assign(
0178         __entry->dev        = gl->gl_name.ln_sbd->sd_vfs->s_dev;
0179         __entry->gltype     = gl->gl_name.ln_type;
0180         __entry->glnum      = gl->gl_name.ln_number;
0181         __entry->cur_state  = glock_trace_state(gl->gl_state);
0182         __entry->dmt_state  = glock_trace_state(gl->gl_demote_state);
0183         __entry->flags      = gl->gl_flags  | (gl->gl_object ? (1UL<<GLF_OBJECT) : 0);
0184         __entry->remote     = remote;
0185     ),
0186 
0187     TP_printk("%u,%u glock %d:%lld demote %s to %s flags:%s %s",
0188           MAJOR(__entry->dev), MINOR(__entry->dev), __entry->gltype,
0189           (unsigned long long)__entry->glnum,
0190                   glock_trace_name(__entry->cur_state),
0191                   glock_trace_name(__entry->dmt_state),
0192           show_glock_flags(__entry->flags),
0193           __entry->remote ? "remote" : "local")
0194 
0195 );
0196 
0197 /* Promotion/grant of a glock */
0198 TRACE_EVENT(gfs2_promote,
0199 
0200     TP_PROTO(const struct gfs2_holder *gh),
0201 
0202     TP_ARGS(gh),
0203 
0204     TP_STRUCT__entry(
0205         __field(        dev_t,  dev                     )
0206         __field(    u64,    glnum           )
0207         __field(    u32,    gltype          )
0208         __field(    u8, state           )
0209     ),
0210 
0211     TP_fast_assign(
0212         __entry->dev    = gh->gh_gl->gl_name.ln_sbd->sd_vfs->s_dev;
0213         __entry->glnum  = gh->gh_gl->gl_name.ln_number;
0214         __entry->gltype = gh->gh_gl->gl_name.ln_type;
0215         __entry->state  = glock_trace_state(gh->gh_state);
0216     ),
0217 
0218     TP_printk("%u,%u glock %u:%llu promote %s",
0219           MAJOR(__entry->dev), MINOR(__entry->dev), __entry->gltype,
0220           (unsigned long long)__entry->glnum,
0221           glock_trace_name(__entry->state))
0222 );
0223 
0224 /* Queue/dequeue a lock request */
0225 TRACE_EVENT(gfs2_glock_queue,
0226 
0227     TP_PROTO(const struct gfs2_holder *gh, int queue),
0228 
0229     TP_ARGS(gh, queue),
0230 
0231     TP_STRUCT__entry(
0232         __field(        dev_t,  dev                     )
0233         __field(    u64,    glnum           )
0234         __field(    u32,    gltype          )
0235         __field(    int,    queue           )
0236         __field(    u8, state           )
0237     ),
0238 
0239     TP_fast_assign(
0240         __entry->dev    = gh->gh_gl->gl_name.ln_sbd->sd_vfs->s_dev;
0241         __entry->glnum  = gh->gh_gl->gl_name.ln_number;
0242         __entry->gltype = gh->gh_gl->gl_name.ln_type;
0243         __entry->queue  = queue;
0244         __entry->state  = glock_trace_state(gh->gh_state);
0245     ),
0246 
0247     TP_printk("%u,%u glock %u:%llu %squeue %s",
0248           MAJOR(__entry->dev), MINOR(__entry->dev), __entry->gltype,
0249           (unsigned long long)__entry->glnum,
0250           __entry->queue ? "" : "de",
0251           glock_trace_name(__entry->state))
0252 );
0253 
0254 /* DLM sends a reply to GFS2 */
0255 TRACE_EVENT(gfs2_glock_lock_time,
0256 
0257     TP_PROTO(const struct gfs2_glock *gl, s64 tdiff),
0258 
0259     TP_ARGS(gl, tdiff),
0260 
0261     TP_STRUCT__entry(
0262         __field(    dev_t,  dev     )
0263         __field(    u64,    glnum       )
0264         __field(    u32,    gltype      )
0265         __field(    int,    status      )
0266         __field(    char,   flags       )
0267         __field(    s64,    tdiff       )
0268         __field(    u64,    srtt        )
0269         __field(    u64,    srttvar     )
0270         __field(    u64,    srttb       )
0271         __field(    u64,    srttvarb    )
0272         __field(    u64,    sirt        )
0273         __field(    u64,    sirtvar     )
0274         __field(    u64,    dcount      )
0275         __field(    u64,    qcount      )
0276     ),
0277 
0278     TP_fast_assign(
0279         __entry->dev            = gl->gl_name.ln_sbd->sd_vfs->s_dev;
0280         __entry->glnum          = gl->gl_name.ln_number;
0281         __entry->gltype         = gl->gl_name.ln_type;
0282         __entry->status     = gl->gl_lksb.sb_status;
0283         __entry->flags      = gl->gl_lksb.sb_flags;
0284         __entry->tdiff      = tdiff;
0285         __entry->srtt       = gl->gl_stats.stats[GFS2_LKS_SRTT];
0286         __entry->srttvar    = gl->gl_stats.stats[GFS2_LKS_SRTTVAR];
0287         __entry->srttb      = gl->gl_stats.stats[GFS2_LKS_SRTTB];
0288         __entry->srttvarb   = gl->gl_stats.stats[GFS2_LKS_SRTTVARB];
0289         __entry->sirt       = gl->gl_stats.stats[GFS2_LKS_SIRT];
0290         __entry->sirtvar    = gl->gl_stats.stats[GFS2_LKS_SIRTVAR];
0291         __entry->dcount     = gl->gl_stats.stats[GFS2_LKS_DCOUNT];
0292         __entry->qcount     = gl->gl_stats.stats[GFS2_LKS_QCOUNT];
0293     ),
0294 
0295     TP_printk("%u,%u glock %d:%lld status:%d flags:%02x tdiff:%lld srtt:%lld/%lld srttb:%lld/%lld sirt:%lld/%lld dcnt:%lld qcnt:%lld",
0296           MAJOR(__entry->dev), MINOR(__entry->dev), __entry->gltype,
0297           (unsigned long long)__entry->glnum,
0298           __entry->status, __entry->flags,
0299           (long long)__entry->tdiff,
0300           (long long)__entry->srtt,
0301           (long long)__entry->srttvar,
0302           (long long)__entry->srttb,
0303           (long long)__entry->srttvarb,
0304           (long long)__entry->sirt,
0305           (long long)__entry->sirtvar,
0306           (long long)__entry->dcount,
0307           (long long)__entry->qcount)
0308 );
0309 
0310 /* Section 2 - Log/journal
0311  *
0312  * Objectives:
0313  * Latency: Log flush time
0314  * Correctness: pin/unpin vs. disk I/O ordering
0315  * Performance: Log usage stats
0316  */
0317 
0318 /* Pin/unpin a block in the log */
0319 TRACE_EVENT(gfs2_pin,
0320 
0321     TP_PROTO(const struct gfs2_bufdata *bd, int pin),
0322 
0323     TP_ARGS(bd, pin),
0324 
0325     TP_STRUCT__entry(
0326         __field(        dev_t,  dev                     )
0327         __field(    int,    pin         )
0328         __field(    u32,    len         )
0329         __field(    sector_t,   block       )
0330         __field(    u64,    ino         )
0331     ),
0332 
0333     TP_fast_assign(
0334         __entry->dev        = bd->bd_gl->gl_name.ln_sbd->sd_vfs->s_dev;
0335         __entry->pin        = pin;
0336         __entry->len        = bd->bd_bh->b_size;
0337         __entry->block      = bd->bd_bh->b_blocknr;
0338         __entry->ino        = bd->bd_gl->gl_name.ln_number;
0339     ),
0340 
0341     TP_printk("%u,%u log %s %llu/%lu inode %llu",
0342           MAJOR(__entry->dev), MINOR(__entry->dev),
0343           __entry->pin ? "pin" : "unpin",
0344           (unsigned long long)__entry->block,
0345           (unsigned long)__entry->len,
0346           (unsigned long long)__entry->ino)
0347 );
0348 
0349 /* Flushing the log */
0350 TRACE_EVENT(gfs2_log_flush,
0351 
0352     TP_PROTO(const struct gfs2_sbd *sdp, int start, u32 flags),
0353 
0354     TP_ARGS(sdp, start, flags),
0355 
0356     TP_STRUCT__entry(
0357         __field(        dev_t,  dev                     )
0358         __field(    int,    start           )
0359         __field(    u64,    log_seq         )
0360         __field(    u32,    flags           )
0361     ),
0362 
0363     TP_fast_assign(
0364         __entry->dev            = sdp->sd_vfs->s_dev;
0365         __entry->start      = start;
0366         __entry->log_seq    = sdp->sd_log_sequence;
0367         __entry->flags      = flags;
0368     ),
0369 
0370     TP_printk("%u,%u log flush %s %llu %llx",
0371           MAJOR(__entry->dev), MINOR(__entry->dev),
0372           __entry->start ? "start" : "end",
0373           (unsigned long long)__entry->log_seq,
0374           (unsigned long long)__entry->flags)
0375 );
0376 
0377 /* Reserving/releasing blocks in the log */
0378 TRACE_EVENT(gfs2_log_blocks,
0379 
0380     TP_PROTO(const struct gfs2_sbd *sdp, int blocks),
0381 
0382     TP_ARGS(sdp, blocks),
0383 
0384     TP_STRUCT__entry(
0385         __field(        dev_t,  dev                     )
0386         __field(    int,    blocks          )
0387         __field(    int,    blks_free       )
0388     ),
0389 
0390     TP_fast_assign(
0391         __entry->dev        = sdp->sd_vfs->s_dev;
0392         __entry->blocks     = blocks;
0393         __entry->blks_free  = atomic_read(&sdp->sd_log_blks_free);
0394     ),
0395 
0396     TP_printk("%u,%u log reserve %d %d", MAJOR(__entry->dev),
0397           MINOR(__entry->dev), __entry->blocks, __entry->blks_free)
0398 );
0399 
0400 /* Writing back the AIL */
0401 TRACE_EVENT(gfs2_ail_flush,
0402 
0403     TP_PROTO(const struct gfs2_sbd *sdp, const struct writeback_control *wbc, int start),
0404 
0405     TP_ARGS(sdp, wbc, start),
0406 
0407     TP_STRUCT__entry(
0408         __field(    dev_t,  dev         )
0409         __field(    int, start          )
0410         __field(    int, sync_mode          )
0411         __field(    long, nr_to_write       )
0412     ),
0413 
0414     TP_fast_assign(
0415         __entry->dev        = sdp->sd_vfs->s_dev;
0416         __entry->start      = start;
0417         __entry->sync_mode  = wbc->sync_mode;
0418         __entry->nr_to_write    = wbc->nr_to_write;
0419     ),
0420 
0421     TP_printk("%u,%u ail flush %s %s %ld", MAJOR(__entry->dev),
0422           MINOR(__entry->dev), __entry->start ? "start" : "end",
0423           __entry->sync_mode == WB_SYNC_ALL ? "all" : "none",
0424           __entry->nr_to_write)
0425 );
0426 
0427 /* Section 3 - bmap
0428  *
0429  * Objectives:
0430  * Latency: Bmap request time
0431  * Performance: Block allocator tracing
0432  * Correctness: Test of disard generation vs. blocks allocated
0433  */
0434 
0435 /* Map an extent of blocks, possibly a new allocation */
0436 TRACE_EVENT(gfs2_bmap,
0437 
0438     TP_PROTO(const struct gfs2_inode *ip, const struct buffer_head *bh,
0439         sector_t lblock, int create, int errno),
0440 
0441     TP_ARGS(ip, bh, lblock, create, errno),
0442 
0443     TP_STRUCT__entry(
0444         __field(        dev_t,  dev                     )
0445         __field(    sector_t, lblock        )
0446         __field(    sector_t, pblock        )
0447         __field(    u64,    inum            )
0448         __field(    unsigned long, state        )
0449         __field(    u32,    len         )
0450         __field(    int,    create          )
0451         __field(    int,    errno           )
0452     ),
0453 
0454     TP_fast_assign(
0455         __entry->dev            = ip->i_gl->gl_name.ln_sbd->sd_vfs->s_dev;
0456         __entry->lblock     = lblock;
0457         __entry->pblock     = buffer_mapped(bh) ?  bh->b_blocknr : 0;
0458         __entry->inum       = ip->i_no_addr;
0459         __entry->state      = bh->b_state;
0460         __entry->len        = bh->b_size;
0461         __entry->create     = create;
0462         __entry->errno      = errno;
0463     ),
0464 
0465     TP_printk("%u,%u bmap %llu map %llu/%lu to %llu flags:%08lx %s %d",
0466           MAJOR(__entry->dev), MINOR(__entry->dev),
0467           (unsigned long long)__entry->inum,
0468           (unsigned long long)__entry->lblock,
0469           (unsigned long)__entry->len,
0470           (unsigned long long)__entry->pblock,
0471           __entry->state, __entry->create ? "create " : "nocreate",
0472           __entry->errno)
0473 );
0474 
0475 TRACE_EVENT(gfs2_iomap_start,
0476 
0477     TP_PROTO(const struct gfs2_inode *ip, loff_t pos, ssize_t length,
0478          u16 flags),
0479 
0480     TP_ARGS(ip, pos, length, flags),
0481 
0482     TP_STRUCT__entry(
0483         __field(        dev_t,  dev                     )
0484         __field(    u64,    inum            )
0485         __field(    loff_t, pos         )
0486         __field(    ssize_t, length         )
0487         __field(    u16,    flags           )
0488     ),
0489 
0490     TP_fast_assign(
0491         __entry->dev            = ip->i_gl->gl_name.ln_sbd->sd_vfs->s_dev;
0492         __entry->inum       = ip->i_no_addr;
0493         __entry->pos        = pos;
0494         __entry->length     = length;
0495         __entry->flags      = flags;
0496     ),
0497 
0498     TP_printk("%u,%u bmap %llu iomap start %llu/%lu flags:%08x",
0499           MAJOR(__entry->dev), MINOR(__entry->dev),
0500           (unsigned long long)__entry->inum,
0501           (unsigned long long)__entry->pos,
0502           (unsigned long)__entry->length, (u16)__entry->flags)
0503 );
0504 
0505 TRACE_EVENT(gfs2_iomap_end,
0506 
0507     TP_PROTO(const struct gfs2_inode *ip, struct iomap *iomap, int ret),
0508 
0509     TP_ARGS(ip, iomap, ret),
0510 
0511     TP_STRUCT__entry(
0512         __field(        dev_t,  dev                     )
0513         __field(    u64,    inum            )
0514         __field(    loff_t, offset          )
0515         __field(    ssize_t, length         )
0516         __field(    sector_t, pblock        )
0517         __field(    u16,    flags           )
0518         __field(    u16,    type            )
0519         __field(    int,    ret         )
0520     ),
0521 
0522     TP_fast_assign(
0523         __entry->dev            = ip->i_gl->gl_name.ln_sbd->sd_vfs->s_dev;
0524         __entry->inum       = ip->i_no_addr;
0525         __entry->offset     = iomap->offset;
0526         __entry->length     = iomap->length;
0527         __entry->pblock     = iomap->addr == IOMAP_NULL_ADDR ? 0 :
0528                      (iomap->addr >> ip->i_inode.i_blkbits);
0529         __entry->flags      = iomap->flags;
0530         __entry->type       = iomap->type;
0531         __entry->ret        = ret;
0532     ),
0533 
0534     TP_printk("%u,%u bmap %llu iomap end %llu/%lu to %llu ty:%d flags:%08x rc:%d",
0535           MAJOR(__entry->dev), MINOR(__entry->dev),
0536           (unsigned long long)__entry->inum,
0537           (unsigned long long)__entry->offset,
0538           (unsigned long)__entry->length,
0539           (long long)__entry->pblock,
0540           (u16)__entry->type,
0541           (u16)__entry->flags, __entry->ret)
0542 );
0543 
0544 /* Keep track of blocks as they are allocated/freed */
0545 TRACE_EVENT(gfs2_block_alloc,
0546 
0547     TP_PROTO(const struct gfs2_inode *ip, struct gfs2_rgrpd *rgd,
0548          u64 block, unsigned len, u8 block_state),
0549 
0550     TP_ARGS(ip, rgd, block, len, block_state),
0551 
0552     TP_STRUCT__entry(
0553         __field(        dev_t,  dev                     )
0554         __field(    u64,    start           )
0555         __field(    u64,    inum            )
0556         __field(    u32,    len         )
0557         __field(    u8, block_state     )
0558         __field(        u64,    rd_addr         )
0559         __field(        u32,    rd_free_clone       )
0560         __field(    u32,    rd_requested        )
0561         __field(    u32,    rd_reserved     )
0562     ),
0563 
0564     TP_fast_assign(
0565         __entry->dev        = rgd->rd_gl->gl_name.ln_sbd->sd_vfs->s_dev;
0566         __entry->start      = block;
0567         __entry->inum       = ip->i_no_addr;
0568         __entry->len        = len;
0569         __entry->block_state    = block_state;
0570         __entry->rd_addr    = rgd->rd_addr;
0571         __entry->rd_free_clone  = rgd->rd_free_clone;
0572         __entry->rd_requested   = rgd->rd_requested;
0573         __entry->rd_reserved    = rgd->rd_reserved;
0574     ),
0575 
0576     TP_printk("%u,%u bmap %llu alloc %llu/%lu %s rg:%llu rf:%u rq:%u rr:%u",
0577           MAJOR(__entry->dev), MINOR(__entry->dev),
0578           (unsigned long long)__entry->inum,
0579           (unsigned long long)__entry->start,
0580           (unsigned long)__entry->len,
0581           block_state_name(__entry->block_state),
0582           (unsigned long long)__entry->rd_addr,
0583           __entry->rd_free_clone,
0584           __entry->rd_requested,
0585           __entry->rd_reserved)
0586 );
0587 
0588 /* Keep track of multi-block reservations as they are allocated/freed */
0589 TRACE_EVENT(gfs2_rs,
0590 
0591     TP_PROTO(const struct gfs2_blkreserv *rs, u8 func),
0592 
0593     TP_ARGS(rs, func),
0594 
0595     TP_STRUCT__entry(
0596         __field(        dev_t,  dev                     )
0597         __field(    u64,    rd_addr         )
0598         __field(    u32,    rd_free_clone       )
0599         __field(    u32,    rd_requested        )
0600         __field(    u32,    rd_reserved     )
0601         __field(    u64,    inum            )
0602         __field(    u64,    start           )
0603         __field(    u32,    requested       )
0604         __field(    u32,    reserved        )
0605         __field(    u8, func            )
0606     ),
0607 
0608     TP_fast_assign(
0609         __entry->dev        = rs->rs_rgd->rd_sbd->sd_vfs->s_dev;
0610         __entry->rd_addr    = rs->rs_rgd->rd_addr;
0611         __entry->rd_free_clone  = rs->rs_rgd->rd_free_clone;
0612         __entry->rd_requested   = rs->rs_rgd->rd_requested;
0613         __entry->rd_reserved    = rs->rs_rgd->rd_reserved;
0614         __entry->inum       = container_of(rs, struct gfs2_inode,
0615                                i_res)->i_no_addr;
0616         __entry->start      = rs->rs_start;
0617         __entry->requested  = rs->rs_requested;
0618         __entry->reserved   = rs->rs_reserved;
0619         __entry->func       = func;
0620     ),
0621 
0622     TP_printk("%u,%u bmap %llu resrv %llu rg:%llu rf:%u rq:%u rr:%u %s q:%u r:%u",
0623           MAJOR(__entry->dev), MINOR(__entry->dev),
0624           (unsigned long long)__entry->inum,
0625           (unsigned long long)__entry->start,
0626           (unsigned long long)__entry->rd_addr,
0627           __entry->rd_free_clone,
0628           __entry->rd_requested,
0629           __entry->rd_reserved,
0630           rs_func_name(__entry->func),
0631           __entry->requested,
0632           __entry->reserved)
0633 );
0634 
0635 #endif /* _TRACE_GFS2_H */
0636 
0637 /* This part must be outside protection */
0638 #undef TRACE_INCLUDE_PATH
0639 #define TRACE_INCLUDE_PATH .
0640 #define TRACE_INCLUDE_FILE trace_gfs2
0641 #include <trace/define_trace.h>
0642
[ 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!