~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/gfs2/trace_gfs2.h

Version: ~ [ linux-5.19-rc8 ] ~ [ linux-5.18.14 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.57 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.133 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.207 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.253 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.289 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.324 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /* SPDX-License-Identifier: GPL-2.0 */
  2 #undef TRACE_SYSTEM
  3 #define TRACE_SYSTEM gfs2
  4 
  5 #if !defined(_TRACE_GFS2_H) || defined(TRACE_HEADER_MULTI_READ)
  6 #define _TRACE_GFS2_H
  7 
  8 #include <linux/tracepoint.h>
  9 
 10 #include <linux/fs.h>
 11 #include <linux/buffer_head.h>
 12 #include <linux/dlmconstants.h>
 13 #include <linux/gfs2_ondisk.h>
 14 #include <linux/writeback.h>
 15 #include <linux/ktime.h>
 16 #include <linux/iomap.h>
 17 #include "incore.h"
 18 #include "glock.h"
 19 #include "rgrp.h"
 20 
 21 #define dlm_state_name(nn) { DLM_LOCK_##nn, #nn }
 22 #define glock_trace_name(x) __print_symbolic(x,         \
 23                             dlm_state_name(IV),         \
 24                             dlm_state_name(NL),         \
 25                             dlm_state_name(CR),         \
 26                             dlm_state_name(CW),         \
 27                             dlm_state_name(PR),         \
 28                             dlm_state_name(PW),         \
 29                             dlm_state_name(EX))
 30 
 31 #define block_state_name(x) __print_symbolic(x,                 \
 32                             { GFS2_BLKST_FREE, "free" },        \
 33                             { GFS2_BLKST_USED, "used" },        \
 34                             { GFS2_BLKST_DINODE, "dinode" },    \
 35                             { GFS2_BLKST_UNLINKED, "unlinked" })
 36 
 37 #define TRACE_RS_DELETE  0
 38 #define TRACE_RS_TREEDEL 1
 39 #define TRACE_RS_INSERT  2
 40 #define TRACE_RS_CLAIM   3
 41 
 42 #define rs_func_name(x) __print_symbolic(x,     \
 43                                          { 0, "del " }, \
 44                                          { 1, "tdel" }, \
 45                                          { 2, "ins " }, \
 46                                          { 3, "clm " })
 47 
 48 #define show_glock_flags(flags) __print_flags(flags, "",        \
 49         {(1UL << GLF_LOCK),                     "l" },          \
 50         {(1UL << GLF_DEMOTE),                   "D" },          \
 51         {(1UL << GLF_PENDING_DEMOTE),           "d" },          \
 52         {(1UL << GLF_DEMOTE_IN_PROGRESS),       "p" },          \
 53         {(1UL << GLF_DIRTY),                    "y" },          \
 54         {(1UL << GLF_LFLUSH),                   "f" },          \
 55         {(1UL << GLF_INVALIDATE_IN_PROGRESS),   "i" },          \
 56         {(1UL << GLF_REPLY_PENDING),            "r" },          \
 57         {(1UL << GLF_INITIAL),                  "I" },          \
 58         {(1UL << GLF_FROZEN),                   "F" },          \
 59         {(1UL << GLF_QUEUED),                   "q" },          \
 60         {(1UL << GLF_LRU),                      "L" },          \
 61         {(1UL << GLF_OBJECT),                   "o" },          \
 62         {(1UL << GLF_BLOCKING),                 "b" })
 63 
 64 #ifndef NUMPTY
 65 #define NUMPTY
 66 static inline u8 glock_trace_state(unsigned int state)
 67 {
 68         switch(state) {
 69         case LM_ST_SHARED:
 70                 return DLM_LOCK_PR;
 71         case LM_ST_DEFERRED:
 72                 return DLM_LOCK_CW;
 73         case LM_ST_EXCLUSIVE:
 74                 return DLM_LOCK_EX;
 75         }
 76         return DLM_LOCK_NL;
 77 }
 78 #endif
 79 
 80 /* Section 1 - Locking
 81  *
 82  * Objectives:
 83  * Latency: Remote demote request to state change
 84  * Latency: Local lock request to state change
 85  * Latency: State change to lock grant
 86  * Correctness: Ordering of local lock state vs. I/O requests
 87  * Correctness: Responses to remote demote requests
 88  */
 89 
 90 /* General glock state change (DLM lock request completes) */
 91 TRACE_EVENT(gfs2_glock_state_change,
 92 
 93         TP_PROTO(const struct gfs2_glock *gl, unsigned int new_state),
 94 
 95         TP_ARGS(gl, new_state),
 96 
 97         TP_STRUCT__entry(
 98                 __field(        dev_t,  dev                     )
 99                 __field(        u64,    glnum                   )
100                 __field(        u32,    gltype                  )
101                 __field(        u8,     cur_state               )
102                 __field(        u8,     new_state               )
103                 __field(        u8,     dmt_state               )
104                 __field(        u8,     tgt_state               )
105                 __field(        unsigned long,  flags           )
106         ),
107 
108         TP_fast_assign(
109                 __entry->dev            = gl->gl_name.ln_sbd->sd_vfs->s_dev;
110                 __entry->glnum          = gl->gl_name.ln_number;
111                 __entry->gltype         = gl->gl_name.ln_type;
112                 __entry->cur_state      = glock_trace_state(gl->gl_state);
113                 __entry->new_state      = glock_trace_state(new_state);
114                 __entry->tgt_state      = glock_trace_state(gl->gl_target);
115                 __entry->dmt_state      = glock_trace_state(gl->gl_demote_state);
116                 __entry->flags          = gl->gl_flags | (gl->gl_object ? (1UL<<GLF_OBJECT) : 0);
117         ),
118 
119         TP_printk("%u,%u glock %d:%lld state %s to %s tgt:%s dmt:%s flags:%s",
120                   MAJOR(__entry->dev), MINOR(__entry->dev), __entry->gltype,
121                  (unsigned long long)__entry->glnum,
122                   glock_trace_name(__entry->cur_state),
123                   glock_trace_name(__entry->new_state),
124                   glock_trace_name(__entry->tgt_state),
125                   glock_trace_name(__entry->dmt_state),
126                   show_glock_flags(__entry->flags))
127 );
128 
129 /* State change -> unlocked, glock is being deallocated */
130 TRACE_EVENT(gfs2_glock_put,
131 
132         TP_PROTO(const struct gfs2_glock *gl),
133 
134         TP_ARGS(gl),
135 
136         TP_STRUCT__entry(
137                 __field(        dev_t,  dev                     )
138                 __field(        u64,    glnum                   )
139                 __field(        u32,    gltype                  )
140                 __field(        u8,     cur_state               )
141                 __field(        unsigned long,  flags           )
142         ),
143 
144         TP_fast_assign(
145                 __entry->dev            = gl->gl_name.ln_sbd->sd_vfs->s_dev;
146                 __entry->gltype         = gl->gl_name.ln_type;
147                 __entry->glnum          = gl->gl_name.ln_number;
148                 __entry->cur_state      = glock_trace_state(gl->gl_state);
149                 __entry->flags          = gl->gl_flags  | (gl->gl_object ? (1UL<<GLF_OBJECT) : 0);
150         ),
151 
152         TP_printk("%u,%u glock %d:%lld state %s => %s flags:%s",
153                   MAJOR(__entry->dev), MINOR(__entry->dev),
154                   __entry->gltype, (unsigned long long)__entry->glnum,
155                   glock_trace_name(__entry->cur_state),
156                   glock_trace_name(DLM_LOCK_IV),
157                   show_glock_flags(__entry->flags))
158 
159 );
160 
161 /* Callback (local or remote) requesting lock demotion */
162 TRACE_EVENT(gfs2_demote_rq,
163 
164         TP_PROTO(const struct gfs2_glock *gl, bool remote),
165 
166         TP_ARGS(gl, remote),
167 
168         TP_STRUCT__entry(
169                 __field(        dev_t,  dev                     )
170                 __field(        u64,    glnum                   )
171                 __field(        u32,    gltype                  )
172                 __field(        u8,     cur_state               )
173                 __field(        u8,     dmt_state               )
174                 __field(        unsigned long,  flags           )
175                 __field(        bool,   remote                  )
176         ),
177 
178         TP_fast_assign(
179                 __entry->dev            = gl->gl_name.ln_sbd->sd_vfs->s_dev;
180                 __entry->gltype         = gl->gl_name.ln_type;
181                 __entry->glnum          = gl->gl_name.ln_number;
182                 __entry->cur_state      = glock_trace_state(gl->gl_state);
183                 __entry->dmt_state      = glock_trace_state(gl->gl_demote_state);
184                 __entry->flags          = gl->gl_flags  | (gl->gl_object ? (1UL<<GLF_OBJECT) : 0);
185                 __entry->remote         = remote;
186         ),
187 
188         TP_printk("%u,%u glock %d:%lld demote %s to %s flags:%s %s",
189                   MAJOR(__entry->dev), MINOR(__entry->dev), __entry->gltype,
190                   (unsigned long long)__entry->glnum,
191                   glock_trace_name(__entry->cur_state),
192                   glock_trace_name(__entry->dmt_state),
193                   show_glock_flags(__entry->flags),
194                   __entry->remote ? "remote" : "local")
195 
196 );
197 
198 /* Promotion/grant of a glock */
199 TRACE_EVENT(gfs2_promote,
200 
201         TP_PROTO(const struct gfs2_holder *gh, int first),
202 
203         TP_ARGS(gh, first),
204 
205         TP_STRUCT__entry(
206                 __field(        dev_t,  dev                     )
207                 __field(        u64,    glnum                   )
208                 __field(        u32,    gltype                  )
209                 __field(        int,    first                   )
210                 __field(        u8,     state                   )
211         ),
212 
213         TP_fast_assign(
214                 __entry->dev    = gh->gh_gl->gl_name.ln_sbd->sd_vfs->s_dev;
215                 __entry->glnum  = gh->gh_gl->gl_name.ln_number;
216                 __entry->gltype = gh->gh_gl->gl_name.ln_type;
217                 __entry->first  = first;
218                 __entry->state  = glock_trace_state(gh->gh_state);
219         ),
220 
221         TP_printk("%u,%u glock %u:%llu promote %s %s",
222                   MAJOR(__entry->dev), MINOR(__entry->dev), __entry->gltype,
223                   (unsigned long long)__entry->glnum,
224                   __entry->first ? "first": "other",
225                   glock_trace_name(__entry->state))
226 );
227 
228 /* Queue/dequeue a lock request */
229 TRACE_EVENT(gfs2_glock_queue,
230 
231         TP_PROTO(const struct gfs2_holder *gh, int queue),
232 
233         TP_ARGS(gh, queue),
234 
235         TP_STRUCT__entry(
236                 __field(        dev_t,  dev                     )
237                 __field(        u64,    glnum                   )
238                 __field(        u32,    gltype                  )
239                 __field(        int,    queue                   )
240                 __field(        u8,     state                   )
241         ),
242 
243         TP_fast_assign(
244                 __entry->dev    = gh->gh_gl->gl_name.ln_sbd->sd_vfs->s_dev;
245                 __entry->glnum  = gh->gh_gl->gl_name.ln_number;
246                 __entry->gltype = gh->gh_gl->gl_name.ln_type;
247                 __entry->queue  = queue;
248                 __entry->state  = glock_trace_state(gh->gh_state);
249         ),
250 
251         TP_printk("%u,%u glock %u:%llu %squeue %s",
252                   MAJOR(__entry->dev), MINOR(__entry->dev), __entry->gltype,
253                   (unsigned long long)__entry->glnum,
254                   __entry->queue ? "" : "de",
255                   glock_trace_name(__entry->state))
256 );
257 
258 /* DLM sends a reply to GFS2 */
259 TRACE_EVENT(gfs2_glock_lock_time,
260 
261         TP_PROTO(const struct gfs2_glock *gl, s64 tdiff),
262 
263         TP_ARGS(gl, tdiff),
264 
265         TP_STRUCT__entry(
266                 __field(        dev_t,  dev             )
267                 __field(        u64,    glnum           )
268                 __field(        u32,    gltype          )
269                 __field(        int,    status          )
270                 __field(        char,   flags           )
271                 __field(        s64,    tdiff           )
272                 __field(        u64,    srtt            )
273                 __field(        u64,    srttvar         )
274                 __field(        u64,    srttb           )
275                 __field(        u64,    srttvarb        )
276                 __field(        u64,    sirt            )
277                 __field(        u64,    sirtvar         )
278                 __field(        u64,    dcount          )
279                 __field(        u64,    qcount          )
280         ),
281 
282         TP_fast_assign(
283                 __entry->dev            = gl->gl_name.ln_sbd->sd_vfs->s_dev;
284                 __entry->glnum          = gl->gl_name.ln_number;
285                 __entry->gltype         = gl->gl_name.ln_type;
286                 __entry->status         = gl->gl_lksb.sb_status;
287                 __entry->flags          = gl->gl_lksb.sb_flags;
288                 __entry->tdiff          = tdiff;
289                 __entry->srtt           = gl->gl_stats.stats[GFS2_LKS_SRTT];
290                 __entry->srttvar        = gl->gl_stats.stats[GFS2_LKS_SRTTVAR];
291                 __entry->srttb          = gl->gl_stats.stats[GFS2_LKS_SRTTB];
292                 __entry->srttvarb       = gl->gl_stats.stats[GFS2_LKS_SRTTVARB];
293                 __entry->sirt           = gl->gl_stats.stats[GFS2_LKS_SIRT];
294                 __entry->sirtvar        = gl->gl_stats.stats[GFS2_LKS_SIRTVAR];
295                 __entry->dcount         = gl->gl_stats.stats[GFS2_LKS_DCOUNT];
296                 __entry->qcount         = gl->gl_stats.stats[GFS2_LKS_QCOUNT];
297         ),
298 
299         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",
300                   MAJOR(__entry->dev), MINOR(__entry->dev), __entry->gltype,
301                   (unsigned long long)__entry->glnum,
302                   __entry->status, __entry->flags,
303                   (long long)__entry->tdiff,
304                   (long long)__entry->srtt,
305                   (long long)__entry->srttvar,
306                   (long long)__entry->srttb,
307                   (long long)__entry->srttvarb,
308                   (long long)__entry->sirt,
309                   (long long)__entry->sirtvar,
310                   (long long)__entry->dcount,
311                   (long long)__entry->qcount)
312 );
313 
314 /* Section 2 - Log/journal
315  *
316  * Objectives:
317  * Latency: Log flush time
318  * Correctness: pin/unpin vs. disk I/O ordering
319  * Performance: Log usage stats
320  */
321 
322 /* Pin/unpin a block in the log */
323 TRACE_EVENT(gfs2_pin,
324 
325         TP_PROTO(const struct gfs2_bufdata *bd, int pin),
326 
327         TP_ARGS(bd, pin),
328 
329         TP_STRUCT__entry(
330                 __field(        dev_t,  dev                     )
331                 __field(        int,    pin                     )
332                 __field(        u32,    len                     )
333                 __field(        sector_t,       block           )
334                 __field(        u64,    ino                     )
335         ),
336 
337         TP_fast_assign(
338                 __entry->dev            = bd->bd_gl->gl_name.ln_sbd->sd_vfs->s_dev;
339                 __entry->pin            = pin;
340                 __entry->len            = bd->bd_bh->b_size;
341                 __entry->block          = bd->bd_bh->b_blocknr;
342                 __entry->ino            = bd->bd_gl->gl_name.ln_number;
343         ),
344 
345         TP_printk("%u,%u log %s %llu/%lu inode %llu",
346                   MAJOR(__entry->dev), MINOR(__entry->dev),
347                   __entry->pin ? "pin" : "unpin",
348                   (unsigned long long)__entry->block,
349                   (unsigned long)__entry->len,
350                   (unsigned long long)__entry->ino)
351 );
352 
353 /* Flushing the log */
354 TRACE_EVENT(gfs2_log_flush,
355 
356         TP_PROTO(const struct gfs2_sbd *sdp, int start, u32 flags),
357 
358         TP_ARGS(sdp, start, flags),
359 
360         TP_STRUCT__entry(
361                 __field(        dev_t,  dev                     )
362                 __field(        int,    start                   )
363                 __field(        u64,    log_seq                 )
364                 __field(        u32,    flags                   )
365         ),
366 
367         TP_fast_assign(
368                 __entry->dev            = sdp->sd_vfs->s_dev;
369                 __entry->start          = start;
370                 __entry->log_seq        = sdp->sd_log_sequence;
371                 __entry->flags          = flags;
372         ),
373 
374         TP_printk("%u,%u log flush %s %llu %llx",
375                   MAJOR(__entry->dev), MINOR(__entry->dev),
376                   __entry->start ? "start" : "end",
377                   (unsigned long long)__entry->log_seq,
378                   (unsigned long long)__entry->flags)
379 );
380 
381 /* Reserving/releasing blocks in the log */
382 TRACE_EVENT(gfs2_log_blocks,
383 
384         TP_PROTO(const struct gfs2_sbd *sdp, int blocks),
385 
386         TP_ARGS(sdp, blocks),
387 
388         TP_STRUCT__entry(
389                 __field(        dev_t,  dev                     )
390                 __field(        int,    blocks                  )
391         ),
392 
393         TP_fast_assign(
394                 __entry->dev            = sdp->sd_vfs->s_dev;
395                 __entry->blocks         = blocks;
396         ),
397 
398         TP_printk("%u,%u log reserve %d", MAJOR(__entry->dev),
399                   MINOR(__entry->dev), __entry->blocks)
400 );
401 
402 /* Writing back the AIL */
403 TRACE_EVENT(gfs2_ail_flush,
404 
405         TP_PROTO(const struct gfs2_sbd *sdp, const struct writeback_control *wbc, int start),
406 
407         TP_ARGS(sdp, wbc, start),
408 
409         TP_STRUCT__entry(
410                 __field(        dev_t,  dev                     )
411                 __field(        int, start                      )
412                 __field(        int, sync_mode                  )
413                 __field(        long, nr_to_write               )
414         ),
415 
416         TP_fast_assign(
417                 __entry->dev            = sdp->sd_vfs->s_dev;
418                 __entry->start          = start;
419                 __entry->sync_mode      = wbc->sync_mode;
420                 __entry->nr_to_write    = wbc->nr_to_write;
421         ),
422 
423         TP_printk("%u,%u ail flush %s %s %ld", MAJOR(__entry->dev),
424                   MINOR(__entry->dev), __entry->start ? "start" : "end",
425                   __entry->sync_mode == WB_SYNC_ALL ? "all" : "none",
426                   __entry->nr_to_write)
427 );
428 
429 /* Section 3 - bmap
430  *
431  * Objectives:
432  * Latency: Bmap request time
433  * Performance: Block allocator tracing
434  * Correctness: Test of disard generation vs. blocks allocated
435  */
436 
437 /* Map an extent of blocks, possibly a new allocation */
438 TRACE_EVENT(gfs2_bmap,
439 
440         TP_PROTO(const struct gfs2_inode *ip, const struct buffer_head *bh,
441                 sector_t lblock, int create, int errno),
442 
443         TP_ARGS(ip, bh, lblock, create, errno),
444 
445         TP_STRUCT__entry(
446                 __field(        dev_t,  dev                     )
447                 __field(        sector_t, lblock                )
448                 __field(        sector_t, pblock                )
449                 __field(        u64,    inum                    )
450                 __field(        unsigned long, state            )
451                 __field(        u32,    len                     )
452                 __field(        int,    create                  )
453                 __field(        int,    errno                   )
454         ),
455 
456         TP_fast_assign(
457                 __entry->dev            = ip->i_gl->gl_name.ln_sbd->sd_vfs->s_dev;
458                 __entry->lblock         = lblock;
459                 __entry->pblock         = buffer_mapped(bh) ?  bh->b_blocknr : 0;
460                 __entry->inum           = ip->i_no_addr;
461                 __entry->state          = bh->b_state;
462                 __entry->len            = bh->b_size;
463                 __entry->create         = create;
464                 __entry->errno          = errno;
465         ),
466 
467         TP_printk("%u,%u bmap %llu map %llu/%lu to %llu flags:%08lx %s %d",
468                   MAJOR(__entry->dev), MINOR(__entry->dev),
469                   (unsigned long long)__entry->inum,
470                   (unsigned long long)__entry->lblock,
471                   (unsigned long)__entry->len,
472                   (unsigned long long)__entry->pblock,
473                   __entry->state, __entry->create ? "create " : "nocreate",
474                   __entry->errno)
475 );
476 
477 TRACE_EVENT(gfs2_iomap_start,
478 
479         TP_PROTO(const struct gfs2_inode *ip, loff_t pos, ssize_t length,
480                  u16 flags),
481 
482         TP_ARGS(ip, pos, length, flags),
483 
484         TP_STRUCT__entry(
485                 __field(        dev_t,  dev                     )
486                 __field(        u64,    inum                    )
487                 __field(        loff_t, pos                     )
488                 __field(        ssize_t, length                 )
489                 __field(        u16,    flags                   )
490         ),
491 
492         TP_fast_assign(
493                 __entry->dev            = ip->i_gl->gl_name.ln_sbd->sd_vfs->s_dev;
494                 __entry->inum           = ip->i_no_addr;
495                 __entry->pos            = pos;
496                 __entry->length         = length;
497                 __entry->flags          = flags;
498         ),
499 
500         TP_printk("%u,%u bmap %llu iomap start %llu/%lu flags:%08x",
501                   MAJOR(__entry->dev), MINOR(__entry->dev),
502                   (unsigned long long)__entry->inum,
503                   (unsigned long long)__entry->pos,
504                   (unsigned long)__entry->length, (u16)__entry->flags)
505 );
506 
507 TRACE_EVENT(gfs2_iomap_end,
508 
509         TP_PROTO(const struct gfs2_inode *ip, struct iomap *iomap, int ret),
510 
511         TP_ARGS(ip, iomap, ret),
512 
513         TP_STRUCT__entry(
514                 __field(        dev_t,  dev                     )
515                 __field(        u64,    inum                    )
516                 __field(        loff_t, offset                  )
517                 __field(        ssize_t, length                 )
518                 __field(        sector_t, pblock                )
519                 __field(        u16,    flags                   )
520                 __field(        u16,    type                    )
521                 __field(        int,    ret                     )
522         ),
523 
524         TP_fast_assign(
525                 __entry->dev            = ip->i_gl->gl_name.ln_sbd->sd_vfs->s_dev;
526                 __entry->inum           = ip->i_no_addr;
527                 __entry->offset         = iomap->offset;
528                 __entry->length         = iomap->length;
529                 __entry->pblock         = iomap->addr == IOMAP_NULL_ADDR ? 0 :
530                                          (iomap->addr >> ip->i_inode.i_blkbits);
531                 __entry->flags          = iomap->flags;
532                 __entry->type           = iomap->type;
533                 __entry->ret            = ret;
534         ),
535 
536         TP_printk("%u,%u bmap %llu iomap end %llu/%lu to %llu ty:%d flags:%08x rc:%d",
537                   MAJOR(__entry->dev), MINOR(__entry->dev),
538                   (unsigned long long)__entry->inum,
539                   (unsigned long long)__entry->offset,
540                   (unsigned long)__entry->length,
541                   (long long)__entry->pblock,
542                   (u16)__entry->type,
543                   (u16)__entry->flags, __entry->ret)
544 );
545 
546 /* Keep track of blocks as they are allocated/freed */
547 TRACE_EVENT(gfs2_block_alloc,
548 
549         TP_PROTO(const struct gfs2_inode *ip, struct gfs2_rgrpd *rgd,
550                  u64 block, unsigned len, u8 block_state),
551 
552         TP_ARGS(ip, rgd, block, len, block_state),
553 
554         TP_STRUCT__entry(
555                 __field(        dev_t,  dev                     )
556                 __field(        u64,    start                   )
557                 __field(        u64,    inum                    )
558                 __field(        u32,    len                     )
559                 __field(        u8,     block_state             )
560                 __field(        u64,    rd_addr                 )
561                 __field(        u32,    rd_free_clone           )
562                 __field(        u32,    rd_reserved             )
563         ),
564 
565         TP_fast_assign(
566                 __entry->dev            = rgd->rd_gl->gl_name.ln_sbd->sd_vfs->s_dev;
567                 __entry->start          = block;
568                 __entry->inum           = ip->i_no_addr;
569                 __entry->len            = len;
570                 __entry->block_state    = block_state;
571                 __entry->rd_addr        = rgd->rd_addr;
572                 __entry->rd_free_clone  = rgd->rd_free_clone;
573                 __entry->rd_reserved    = rgd->rd_reserved;
574         ),
575 
576         TP_printk("%u,%u bmap %llu alloc %llu/%lu %s rg:%llu rf:%u rr:%lu",
577                   MAJOR(__entry->dev), MINOR(__entry->dev),
578                   (unsigned long long)__entry->inum,
579                   (unsigned long long)__entry->start,
580                   (unsigned long)__entry->len,
581                   block_state_name(__entry->block_state),
582                   (unsigned long long)__entry->rd_addr,
583                   __entry->rd_free_clone, (unsigned long)__entry->rd_reserved)
584 );
585 
586 /* Keep track of multi-block reservations as they are allocated/freed */
587 TRACE_EVENT(gfs2_rs,
588 
589         TP_PROTO(const struct gfs2_blkreserv *rs, u8 func),
590 
591         TP_ARGS(rs, func),
592 
593         TP_STRUCT__entry(
594                 __field(        dev_t,  dev                     )
595                 __field(        u64,    rd_addr                 )
596                 __field(        u32,    rd_free_clone           )
597                 __field(        u32,    rd_reserved             )
598                 __field(        u64,    inum                    )
599                 __field(        u64,    start                   )
600                 __field(        u32,    free                    )
601                 __field(        u8,     func                    )
602         ),
603 
604         TP_fast_assign(
605                 __entry->dev            = rs->rs_rbm.rgd->rd_sbd->sd_vfs->s_dev;
606                 __entry->rd_addr        = rs->rs_rbm.rgd->rd_addr;
607                 __entry->rd_free_clone  = rs->rs_rbm.rgd->rd_free_clone;
608                 __entry->rd_reserved    = rs->rs_rbm.rgd->rd_reserved;
609                 __entry->inum           = container_of(rs, struct gfs2_inode,
610                                                        i_res)->i_no_addr;
611                 __entry->start          = gfs2_rbm_to_block(&rs->rs_rbm);
612                 __entry->free           = rs->rs_free;
613                 __entry->func           = func;
614         ),
615 
616         TP_printk("%u,%u bmap %llu resrv %llu rg:%llu rf:%lu rr:%lu %s f:%lu",
617                   MAJOR(__entry->dev), MINOR(__entry->dev),
618                   (unsigned long long)__entry->inum,
619                   (unsigned long long)__entry->start,
620                   (unsigned long long)__entry->rd_addr,
621                   (unsigned long)__entry->rd_free_clone,
622                   (unsigned long)__entry->rd_reserved,
623                   rs_func_name(__entry->func), (unsigned long)__entry->free)
624 );
625 
626 #endif /* _TRACE_GFS2_H */
627 
628 /* This part must be outside protection */
629 #undef TRACE_INCLUDE_PATH
630 #define TRACE_INCLUDE_PATH .
631 #define TRACE_INCLUDE_FILE trace_gfs2
632 #include <trace/define_trace.h>
633 
634 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp