trace_gfs2.h 18 KB

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