From 5b7f9ddbe2490a014d981e1696bd6624a3e4e1d4 Mon Sep 17 00:00:00 2001 From: Mark Fasheh Date: Wed, 12 Oct 2016 14:10:05 -0700 Subject: [PATCH] Trace scoutfs btree functions We make an event class for the two most common btree op patterns, and reuse that to make our tracepoints for each function. This covers all the entry points listed in btree.h. We don't get every single parameter of every function but this is enough that we can see which keys are being queried / inserted. Signed-off-by: Mark Fasheh Signed-off-by: Zach Brown --- kmod/src/btree.c | 20 +++++- kmod/src/scoutfs_trace.h | 127 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 144 insertions(+), 3 deletions(-) diff --git a/kmod/src/btree.c b/kmod/src/btree.c index fbd40f7c..441fb36b 100644 --- a/kmod/src/btree.c +++ b/kmod/src/btree.c @@ -21,6 +21,8 @@ #include "key.h" #include "btree.h" +#include "scoutfs_trace.h" + /* * scoutfs stores file system metadata in btrees whose items have fixed * sized keys and variable length values. @@ -1166,8 +1168,7 @@ int scoutfs_btree_lookup(struct super_block *sb, int cmp; int ret; - trace_printk("key "CKF" val_len %d\n", - CKA(key), scoutfs_btree_val_length(val)); + trace_scoutfs_btree_lookup(sb, key, scoutfs_btree_val_length(val)); bh = btree_walk(sb, root, key, NULL, 0, 0, 0); if (IS_ERR(bh)) @@ -1217,6 +1218,8 @@ int scoutfs_btree_insert(struct super_block *sb, else val_len = 0; + trace_scoutfs_btree_insert(sb, key, val_len); + if (WARN_ON_ONCE(val_len > SCOUTFS_MAX_ITEM_LEN)) return -EINVAL; @@ -1256,6 +1259,8 @@ int scoutfs_btree_delete(struct super_block *sb, int cmp; int ret; + trace_scoutfs_btree_delete(sb, key, 0); + bh = btree_walk(sb, root, key, NULL, 0, 0, WALK_DELETE); if (IS_ERR(bh)) { ret = PTR_ERR(bh); @@ -1383,6 +1388,8 @@ int scoutfs_btree_next(struct super_block *sb, struct scoutfs_btree_root *root, struct scoutfs_key *found, struct scoutfs_btree_val *val) { + trace_scoutfs_btree_next(sb, first, last); + return btree_next(sb, root, first, last, 0, WALK_NEXT, found, NULL, val); } @@ -1393,6 +1400,8 @@ int scoutfs_btree_since(struct super_block *sb, u64 seq, struct scoutfs_key *found, u64 *found_seq, struct scoutfs_btree_val *val) { + trace_scoutfs_btree_since(sb, first, last); + return btree_next(sb, root, first, last, seq, WALK_NEXT_SEQ, found, found_seq, val); } @@ -1413,7 +1422,7 @@ int scoutfs_btree_dirty(struct super_block *sb, int cmp; int ret; - trace_printk("key "CKF"\n", CKA(key)); + trace_scoutfs_btree_dirty(sb, key, 0); bh = btree_walk(sb, root, key, NULL, 0, 0, WALK_DIRTY); if (IS_ERR(bh)) @@ -1454,6 +1463,9 @@ int scoutfs_btree_update(struct super_block *sb, int cmp; int ret; + trace_scoutfs_btree_update(sb, key, + val ? scoutfs_btree_val_length(val) : 0); + bh = btree_walk(sb, root, key, NULL, 0, 0, WALK_DIRTY); if (IS_ERR(bh)) return PTR_ERR(bh); @@ -1497,6 +1509,8 @@ int scoutfs_btree_hole(struct super_block *sb, struct scoutfs_btree_root *root, struct scoutfs_key found; int ret; + trace_scoutfs_btree_hole(sb, first, last); + if (WARN_ON_ONCE(scoutfs_key_cmp(first, last) > 0)) { scoutfs_key_set_zero(hole); return -EINVAL; diff --git a/kmod/src/scoutfs_trace.h b/kmod/src/scoutfs_trace.h index fb96658d..81cef012 100644 --- a/kmod/src/scoutfs_trace.h +++ b/kmod/src/scoutfs_trace.h @@ -23,10 +23,26 @@ #define _TRACE_SCOUTFS_H #include +#include #include "key.h" #include "format.h" +struct scoutfs_sb_info; + +#define show_key_type(type) \ + __print_symbolic(type, \ + { SCOUTFS_INODE_KEY, "INODE" }, \ + { SCOUTFS_XATTR_KEY, "XATTR" }, \ + { SCOUTFS_XATTR_NAME_HASH_KEY, "XATTR_NAME_HASH"}, \ + { SCOUTFS_XATTR_VAL_HASH_KEY, "XATTR_VAL_HASH" }, \ + { SCOUTFS_DIRENT_KEY, "DIRENT" }, \ + { SCOUTFS_LINK_BACKREF_KEY, "LINK_BACKREF"}, \ + { SCOUTFS_SYMLINK_KEY, "SYMLINK" }, \ + { SCOUTFS_BMAP_KEY, "BMAP" }) + +#define TRACE_KEYF "%llu.%s.%llu" + TRACE_EVENT(scoutfs_write_begin, TP_PROTO(u64 ino, loff_t pos, unsigned len), @@ -156,6 +172,117 @@ TRACE_EVENT(scoutfs_buddy_free, __entry->blkno, __entry->order, __entry->region, __entry->ret) ); +DECLARE_EVENT_CLASS(scoutfs_btree_op, + TP_PROTO(struct super_block *sb, struct scoutfs_key *key, int len), + + TP_ARGS(sb, key, len), + + TP_STRUCT__entry( + __field( dev_t, dev ) + __field( u64, key_ino ) + __field( u64, key_off ) + __field( u8, key_type ) + __field( int, val_len ) + ), + + TP_fast_assign( + __entry->dev = sb->s_dev; + __entry->key_ino = le64_to_cpu(key->inode); + __entry->key_off = le64_to_cpu(key->offset); + __entry->key_type = key->type; + __entry->val_len = len; + ), + + TP_printk("dev %d,%d key "TRACE_KEYF" size %d", + MAJOR(__entry->dev), MINOR(__entry->dev), + __entry->key_ino, show_key_type(__entry->key_type), + __entry->key_off, __entry->val_len) +); + +DEFINE_EVENT(scoutfs_btree_op, scoutfs_btree_lookup, + TP_PROTO(struct super_block *sb, struct scoutfs_key *key, int len), + + TP_ARGS(sb, key, len) +); + +DEFINE_EVENT(scoutfs_btree_op, scoutfs_btree_insert, + TP_PROTO(struct super_block *sb, struct scoutfs_key *key, int len), + + TP_ARGS(sb, key, len) +); + +DEFINE_EVENT(scoutfs_btree_op, scoutfs_btree_delete, + TP_PROTO(struct super_block *sb, struct scoutfs_key *key, int len), + + TP_ARGS(sb, key, len) +); + +DEFINE_EVENT(scoutfs_btree_op, scoutfs_btree_dirty, + TP_PROTO(struct super_block *sb, struct scoutfs_key *key, int len), + + TP_ARGS(sb, key, len) +); + +DEFINE_EVENT(scoutfs_btree_op, scoutfs_btree_update, + TP_PROTO(struct super_block *sb, struct scoutfs_key *key, int len), + + TP_ARGS(sb, key, len) +); + +DECLARE_EVENT_CLASS(scoutfs_btree_ranged_op, + TP_PROTO(struct super_block *sb, struct scoutfs_key *first, + struct scoutfs_key *last), + + TP_ARGS(sb, first, last), + + TP_STRUCT__entry( + __field( dev_t, dev ) + __field( u64, first_ino ) + __field( u64, first_off ) + __field( u8, first_type ) + __field( u64, last_ino ) + __field( u64, last_off ) + __field( u8, last_type ) + ), + + TP_fast_assign( + __entry->dev = sb->s_dev; + __entry->first_ino = le64_to_cpu(first->inode); + __entry->first_off = le64_to_cpu(first->offset); + __entry->first_type = first->type; + __entry->last_ino = le64_to_cpu(last->inode); + __entry->last_off = le64_to_cpu(last->offset); + __entry->last_type = last->type; + ), + + TP_printk("dev %d,%d first key "TRACE_KEYF" last key "TRACE_KEYF, + MAJOR(__entry->dev), MINOR(__entry->dev), __entry->first_ino, + show_key_type(__entry->first_type), __entry->first_off, + __entry->last_ino, show_key_type(__entry->last_type), + __entry->last_off) +); + +DEFINE_EVENT(scoutfs_btree_ranged_op, scoutfs_btree_hole, + TP_PROTO(struct super_block *sb, struct scoutfs_key *first, + struct scoutfs_key *last), + + TP_ARGS(sb, first, last) +); + +DEFINE_EVENT(scoutfs_btree_ranged_op, scoutfs_btree_next, + TP_PROTO(struct super_block *sb, struct scoutfs_key *first, + struct scoutfs_key *last), + + TP_ARGS(sb, first, last) +); + +DEFINE_EVENT(scoutfs_btree_ranged_op, scoutfs_btree_since, + TP_PROTO(struct super_block *sb, struct scoutfs_key *first, + struct scoutfs_key *last), + + TP_ARGS(sb, first, last) +); + #endif /* _TRACE_SCOUTFS_H */ /* This part must be outside protection */