From dfac36a9aa48ebffadf2dc8c92fa72049ec1766b Mon Sep 17 00:00:00 2001 From: Zach Brown Date: Tue, 26 Jun 2018 14:54:08 -0700 Subject: [PATCH] scoutfs: trace key struct The userspace trace event printing code has trouble with arguments that refer to fields in entries. Add macros to make entries for all the fields and use them as the formatted arguments. We also remove the mapping of zone and type to strings. It's smaller to print the values directly and gets rid of some silly code. Signed-off-by: Zach Brown --- kmod/src/Makefile | 2 +- kmod/src/key.c | 58 -------------- kmod/src/key.h | 71 ++++++++++------- kmod/src/scoutfs_trace.h | 166 +++++++++++++++++++-------------------- kmod/src/super.c | 1 - 5 files changed, 125 insertions(+), 173 deletions(-) delete mode 100644 kmod/src/key.c diff --git a/kmod/src/Makefile b/kmod/src/Makefile index 61b12f70..73589b6c 100644 --- a/kmod/src/Makefile +++ b/kmod/src/Makefile @@ -6,7 +6,7 @@ CFLAGS_super.o = -DSCOUTFS_GIT_DESCRIBE=\"$(SCOUTFS_GIT_DESCRIBE)\" \ CFLAGS_scoutfs_trace.o = -I$(src) # define_trace.h double include scoutfs-y += bio.o btree.o client.o compact.o counters.o data.o dir.o \ - export.o extents.o file.o inode.o ioctl.o item.o key.o lock.o \ + export.o extents.o file.o inode.o ioctl.o item.o lock.o \ manifest.o msg.o options.o per_task.o seg.o server.o \ scoutfs_trace.o sock.o sort_priv.o super.o sysfs.o trans.o \ triggers.o xattr.o diff --git a/kmod/src/key.c b/kmod/src/key.c deleted file mode 100644 index 9c1603b5..00000000 --- a/kmod/src/key.c +++ /dev/null @@ -1,58 +0,0 @@ -/* - * Copyright (C) 2018 Versity Software, Inc. All rights reserved. - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public - * License v2 as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * General Public License for more details. - */ -#include -#include -#include - -#include "format.h" -#include "key.h" - -char *scoutfs_zone_strings[SCOUTFS_MAX_ZONE] = { - [SCOUTFS_INODE_INDEX_ZONE] = "ind", - [SCOUTFS_NODE_ZONE] = "nod", - [SCOUTFS_FS_ZONE] = "fs", -}; - -char *scoutfs_type_strings[SCOUTFS_MAX_ZONE][SCOUTFS_MAX_TYPE] = { - [SCOUTFS_INODE_INDEX_ZONE][SCOUTFS_INODE_INDEX_META_SEQ_TYPE] = "msq", - [SCOUTFS_INODE_INDEX_ZONE][SCOUTFS_INODE_INDEX_DATA_SEQ_TYPE] = "dsq", - [SCOUTFS_NODE_ZONE][SCOUTFS_FREE_EXTENT_BLKNO_TYPE] = "fbn", - [SCOUTFS_NODE_ZONE][SCOUTFS_FREE_EXTENT_BLOCKS_TYPE] = "fbs", - [SCOUTFS_NODE_ZONE][SCOUTFS_ORPHAN_TYPE] = "orp", - [SCOUTFS_FS_ZONE][SCOUTFS_INODE_TYPE] = "ino", - [SCOUTFS_FS_ZONE][SCOUTFS_XATTR_TYPE] = "xat", - [SCOUTFS_FS_ZONE][SCOUTFS_DIRENT_TYPE] = "dnt", - [SCOUTFS_FS_ZONE][SCOUTFS_READDIR_TYPE] = "rdr", - [SCOUTFS_FS_ZONE][SCOUTFS_LINK_BACKREF_TYPE] = "lbr", - [SCOUTFS_FS_ZONE][SCOUTFS_SYMLINK_TYPE] = "sym", - [SCOUTFS_FS_ZONE][SCOUTFS_FILE_EXTENT_TYPE] = "fex", -}; - -char scoutfs_unknown_u8_strings[U8_MAX][U8_STR_MAX]; - -int __init scoutfs_key_init(void) -{ - int ret; - int i; - - for (i = 0; i <= U8_MAX; i++) { - ret = snprintf(scoutfs_unknown_u8_strings[i], U8_STR_MAX, - "u%u", i); - if (WARN_ONCE(ret <= 0 || ret >= U8_STR_MAX, - "snprintf("__stringify(U8_STR_MAX)") ret %d\n", - ret)) - return -EINVAL; - } - - return 0; -} diff --git a/kmod/src/key.h b/kmod/src/key.h index eb157279..abe89ee0 100644 --- a/kmod/src/key.h +++ b/kmod/src/key.h @@ -6,39 +6,52 @@ #include "cmp.h" #include "endian_swap.h" -extern char *scoutfs_zone_strings[SCOUTFS_MAX_ZONE]; -extern char *scoutfs_type_strings[SCOUTFS_MAX_ZONE][SCOUTFS_MAX_TYPE]; -#define U8_STR_MAX 5 /* u%3u'\0' */ -extern char scoutfs_unknown_u8_strings[U8_MAX][U8_STR_MAX]; +#define SK_FMT "%u.%llu.%u.%llu.%llu.%u" -int __init scoutfs_key_init(void); - -static inline char *sk_zone_str(u8 zone) -{ - if (zone >= SCOUTFS_MAX_ZONE || scoutfs_zone_strings[zone] == NULL) - return scoutfs_unknown_u8_strings[zone]; - - return scoutfs_zone_strings[zone]; -} - -static inline char *sk_type_str(u8 zone, u8 type) -{ - if (zone >= SCOUTFS_MAX_ZONE || type >= SCOUTFS_MAX_TYPE || - scoutfs_type_strings[zone][type] == NULL) - return scoutfs_unknown_u8_strings[type]; - - return scoutfs_type_strings[zone][type]; -} - -#define SK_FMT "%s.%llu.%s.%llu.%llu.%u" /* This does not support null keys */ -#define SK_ARG(key) sk_zone_str((key)->sk_zone), \ - le64_to_cpu((key)->_sk_first), \ - sk_type_str((key)->sk_zone, (key)->sk_type), \ - le64_to_cpu((key)->_sk_second), \ - le64_to_cpu((key)->_sk_third), \ +#define SK_ARG(key) (key)->sk_zone, \ + le64_to_cpu((key)->_sk_first), \ + (key)->sk_type, \ + le64_to_cpu((key)->_sk_second), \ + le64_to_cpu((key)->_sk_third), \ (key)->_sk_fourth +/* userspace trace event printing doesn't like arguments with structure + * field references. So we explode structures into their fields instead + * of + */ +#define sk_trace_define(name) \ + __field(__u8, name##_zone) \ + __field(__u64, name##_first) \ + __field(__u8, name##_type) \ + __field(__u64, name##_second) \ + __field(__u64, name##_third) \ + __field(__u8, name##_fourth) + +#define sk_trace_assign(name, key) \ +do { \ + __typeof__(key) _key = (key); \ + if (_key) { \ + __entry->name##_zone = _key->sk_zone; \ + __entry->name##_first = le64_to_cpu(_key->_sk_first); \ + __entry->name##_type = _key->sk_type; \ + __entry->name##_second = le64_to_cpu(_key->_sk_second);\ + __entry->name##_third = le64_to_cpu(_key->_sk_third); \ + __entry->name##_fourth = _key->_sk_fourth; \ + } else { \ + __entry->name##_zone = 0; \ + __entry->name##_first = 0; \ + __entry->name##_type = 0; \ + __entry->name##_second = 0; \ + __entry->name##_third = 0; \ + __entry->name##_fourth = 0; \ + } \ +} while (0) + +#define sk_trace_args(name) \ + __entry->name##_zone, __entry->name##_first, __entry->name##_type, \ + __entry->name##_second, __entry->name##_third, __entry->name##_fourth + static inline void scoutfs_key_set_zeros(struct scoutfs_key *key) { key->sk_zone = 0; diff --git a/kmod/src/scoutfs_trace.h b/kmod/src/scoutfs_trace.h index 56eae869..dc7568b0 100644 --- a/kmod/src/scoutfs_trace.h +++ b/kmod/src/scoutfs_trace.h @@ -235,18 +235,18 @@ DECLARE_EVENT_CLASS(scoutfs_key_ret_class, TP_STRUCT__entry( __field(__u64, fsid) - __field_struct(struct scoutfs_key, key) + sk_trace_define(key) __field(int, ret) ), TP_fast_assign( __entry->fsid = FSID_ARG(sb); - __entry->key = *key; + sk_trace_assign(key, key); __entry->ret = ret; ), TP_printk("fsid "FSID_FMT" key "SK_FMT" ret %d", - __entry->fsid, SK_ARG(&__entry->key), __entry->ret) + __entry->fsid, sk_trace_args(key), __entry->ret) ); DEFINE_EVENT(scoutfs_key_ret_class, scoutfs_item_create, @@ -1243,19 +1243,19 @@ DECLARE_EVENT_CLASS(scoutfs_manifest_class, __field(u8, level) __field(u64, segno) __field(u64, seq) - __field_struct(struct scoutfs_key, first) - __field_struct(struct scoutfs_key, last) + sk_trace_define(first) + sk_trace_define(last) ), TP_fast_assign( __entry->level = level; __entry->segno = segno; __entry->seq = seq; - scoutfs_key_copy_or_zeros(&__entry->first, first); - scoutfs_key_copy_or_zeros(&__entry->last, last); + sk_trace_assign(first, first); + sk_trace_assign(last, last); ), TP_printk("level %u segno %llu seq %llu first "SK_FMT" last "SK_FMT, __entry->level, __entry->segno, __entry->seq, - SK_ARG(&__entry->first), SK_ARG(&__entry->last)) + sk_trace_args(first), sk_trace_args(last)) ); DEFINE_EVENT(scoutfs_manifest_class, scoutfs_manifest_add, @@ -1292,24 +1292,24 @@ TRACE_EVENT(scoutfs_read_item_keys, TP_ARGS(sb, key, start, end, seg_start, seg_end), TP_STRUCT__entry( __field(__u64, fsid) - __field_struct(struct scoutfs_key, key) - __field_struct(struct scoutfs_key, start) - __field_struct(struct scoutfs_key, end) - __field_struct(struct scoutfs_key, seg_start) - __field_struct(struct scoutfs_key, seg_end) + sk_trace_define(key) + sk_trace_define(start) + sk_trace_define(end) + sk_trace_define(seg_start) + sk_trace_define(seg_end) ), TP_fast_assign( __entry->fsid = FSID_ARG(sb); - scoutfs_key_copy_or_zeros(&__entry->key, key); - scoutfs_key_copy_or_zeros(&__entry->start, start); - scoutfs_key_copy_or_zeros(&__entry->end, end); - scoutfs_key_copy_or_zeros(&__entry->seg_start, seg_start); - scoutfs_key_copy_or_zeros(&__entry->seg_end, seg_end); + sk_trace_assign(key, key); + sk_trace_assign(start, start); + sk_trace_assign(end, end); + sk_trace_assign(seg_start, seg_start); + sk_trace_assign(seg_end, seg_end); ), TP_printk("fsid "FSID_FMT" key "SK_FMT" start "SK_FMT" end "SK_FMT" seg_start "SK_FMT" seg_end "SK_FMT"", - __entry->fsid, SK_ARG(&__entry->key), SK_ARG(&__entry->start), - SK_ARG(&__entry->end), SK_ARG(&__entry->seg_start), - SK_ARG(&__entry->seg_end)) + __entry->fsid, sk_trace_args(key), sk_trace_args(start), + sk_trace_args(end), sk_trace_args(seg_start), + sk_trace_args(seg_end)) ); DECLARE_EVENT_CLASS(scoutfs_key_class, @@ -1317,13 +1317,13 @@ DECLARE_EVENT_CLASS(scoutfs_key_class, TP_ARGS(sb, key), TP_STRUCT__entry( __field(__u64, fsid) - __field_struct(struct scoutfs_key, key) + sk_trace_define(key) ), TP_fast_assign( __entry->fsid = FSID_ARG(sb); - scoutfs_key_copy_or_zeros(&__entry->key, key); + sk_trace_assign(key, key); ), - TP_printk(FSID_FMT" key "SK_FMT, __entry->fsid, SK_ARG(&__entry->key)) + TP_printk(FSID_FMT" key "SK_FMT, __entry->fsid, sk_trace_args(key)) ); DEFINE_EVENT(scoutfs_key_class, scoutfs_item_lookup, @@ -1370,17 +1370,16 @@ DECLARE_EVENT_CLASS(scoutfs_range_class, TP_ARGS(sb, start, end), TP_STRUCT__entry( __field(__u64, fsid) - __field_struct(struct scoutfs_key, start) - __field_struct(struct scoutfs_key, end) + sk_trace_define(start) + sk_trace_define(end) ), TP_fast_assign( __entry->fsid = FSID_ARG(sb); - scoutfs_key_copy_or_zeros(&__entry->start, start); - scoutfs_key_copy_or_zeros(&__entry->end, end); + sk_trace_assign(start, start); + sk_trace_assign(end, end); ), TP_printk("fsid "FSID_FMT" start "SK_FMT" end "SK_FMT, - __entry->fsid, SK_ARG(&__entry->start), - SK_ARG(&__entry->end)) + __entry->fsid, sk_trace_args(start), sk_trace_args(end)) ); DEFINE_EVENT(scoutfs_range_class, scoutfs_item_insert_batch, @@ -1402,18 +1401,18 @@ DECLARE_EVENT_CLASS(scoutfs_cached_range_class, TP_STRUCT__entry( __field(__u64, fsid) __field(void *, rng) - __field_struct(struct scoutfs_key, start) - __field_struct(struct scoutfs_key, end) + sk_trace_define(start) + sk_trace_define(end) ), TP_fast_assign( __entry->fsid = FSID_ARG(sb); __entry->rng = rng; - scoutfs_key_copy_or_zeros(&__entry->start, start); - scoutfs_key_copy_or_zeros(&__entry->end, end); + sk_trace_assign(start, start); + sk_trace_assign(end, end); ), TP_printk("fsid "FSID_FMT" rng %p start "SK_FMT" end "SK_FMT, - __entry->fsid, __entry->rng, SK_ARG(&__entry->start), - SK_ARG(&__entry->end)) + __entry->fsid, __entry->rng, sk_trace_args(start), + sk_trace_args(end)) ); DEFINE_EVENT(scoutfs_cached_range_class, scoutfs_item_range_free, @@ -1617,7 +1616,7 @@ TRACE_EVENT(scoutfs_seg_append_item, __field(__u64, seq) __field(__u32, nr_items) __field(__u32, total_bytes) - __field_struct(struct scoutfs_key, key) + sk_trace_define(key) __field(__u16, val_len) ), @@ -1627,15 +1626,14 @@ TRACE_EVENT(scoutfs_seg_append_item, __entry->seq = seq; __entry->nr_items = nr_items; __entry->total_bytes = total_bytes; - __entry->key = *key; + sk_trace_assign(key, key); __entry->val_len = val_len; ), TP_printk("fsid "FSID_FMT" segno %llu seq %llu nr_items %u total_bytes %u key "SK_FMT" val_len %u", __entry->fsid, __entry->segno, __entry->seq, __entry->nr_items, __entry->total_bytes, - SK_ARG(&__entry->key), - __entry->val_len) + sk_trace_args(key), __entry->val_len) ); DECLARE_EVENT_CLASS(scoutfs_net_class, @@ -1753,25 +1751,25 @@ TRACE_EVENT(scoutfs_item_next_range_check, TP_STRUCT__entry( __field(void *, sb) __field(int, cached) - __field_struct(struct scoutfs_key, key) - __field_struct(struct scoutfs_key, pos) - __field_struct(struct scoutfs_key, last) - __field_struct(struct scoutfs_key, end) - __field_struct(struct scoutfs_key, range_end) + sk_trace_define(key) + sk_trace_define(pos) + sk_trace_define(last) + sk_trace_define(end) + sk_trace_define(range_end) ), TP_fast_assign( __entry->sb = sb; __entry->cached = cached; - scoutfs_key_copy_or_zeros(&__entry->key, key); - scoutfs_key_copy_or_zeros(&__entry->pos, pos); - scoutfs_key_copy_or_zeros(&__entry->last, last); - scoutfs_key_copy_or_zeros(&__entry->end, end); - scoutfs_key_copy_or_zeros(&__entry->range_end, range_end); + sk_trace_assign(key, key); + sk_trace_assign(pos, pos); + sk_trace_assign(last, last); + sk_trace_assign(end, end); + sk_trace_assign(range_end, range_end); ), TP_printk("sb %p cached %d key "SK_FMT" pos "SK_FMT" last "SK_FMT" end "SK_FMT" range_end "SK_FMT, - __entry->sb, __entry->cached, SK_ARG(&__entry->key), - SK_ARG(&__entry->pos), SK_ARG(&__entry->last), - SK_ARG(&__entry->end), SK_ARG(&__entry->range_end)) + __entry->sb, __entry->cached, sk_trace_args(key), + sk_trace_args(pos), sk_trace_args(last), + sk_trace_args(end), sk_trace_args(range_end)) ); TRACE_EVENT(scoutfs_item_prev_range_check, @@ -1783,25 +1781,25 @@ TRACE_EVENT(scoutfs_item_prev_range_check, TP_STRUCT__entry( __field(void *, sb) __field(int, cached) - __field_struct(struct scoutfs_key, key) - __field_struct(struct scoutfs_key, pos) - __field_struct(struct scoutfs_key, first) - __field_struct(struct scoutfs_key, start) - __field_struct(struct scoutfs_key, range_start) + sk_trace_define(key) + sk_trace_define(pos) + sk_trace_define(first) + sk_trace_define(start) + sk_trace_define(range_start) ), TP_fast_assign( __entry->sb = sb; __entry->cached = cached; - scoutfs_key_copy_or_zeros(&__entry->key, key); - scoutfs_key_copy_or_zeros(&__entry->pos, pos); - scoutfs_key_copy_or_zeros(&__entry->first, first); - scoutfs_key_copy_or_zeros(&__entry->start, start); - scoutfs_key_copy_or_zeros(&__entry->range_start, range_start); + sk_trace_assign(key, key); + sk_trace_assign(pos, pos); + sk_trace_assign(first, first); + sk_trace_assign(start, start); + sk_trace_assign(range_start, range_start); ), TP_printk("sb %p cached %d key "SK_FMT" pos "SK_FMT" first "SK_FMT" start "SK_FMT" range_start "SK_FMT, - __entry->sb, __entry->cached, SK_ARG(&__entry->key), - SK_ARG(&__entry->pos), SK_ARG(&__entry->first), - SK_ARG(&__entry->start), SK_ARG(&__entry->range_start)) + __entry->sb, __entry->cached, sk_trace_args(key), + sk_trace_args(pos), sk_trace_args(first), + sk_trace_args(start), sk_trace_args(range_start)) ); DECLARE_EVENT_CLASS(scoutfs_shrink_exit_class, @@ -1845,29 +1843,29 @@ TRACE_EVENT(scoutfs_item_shrink_around, TP_ARGS(sb, rng_start, rng_end, item, prev, first, last, next), TP_STRUCT__entry( __field(void *, sb) - __field_struct(struct scoutfs_key, rng_start) - __field_struct(struct scoutfs_key, rng_end) - __field_struct(struct scoutfs_key, item) - __field_struct(struct scoutfs_key, prev) - __field_struct(struct scoutfs_key, first) - __field_struct(struct scoutfs_key, last) - __field_struct(struct scoutfs_key, next) + sk_trace_define(rng_start) + sk_trace_define(rng_end) + sk_trace_define(item) + sk_trace_define(prev) + sk_trace_define(first) + sk_trace_define(last) + sk_trace_define(next) ), TP_fast_assign( __entry->sb = sb; - scoutfs_key_copy_or_zeros(&__entry->rng_start, rng_start); - scoutfs_key_copy_or_zeros(&__entry->rng_end, rng_end); - scoutfs_key_copy_or_zeros(&__entry->item, item); - scoutfs_key_copy_or_zeros(&__entry->prev, prev); - scoutfs_key_copy_or_zeros(&__entry->first, first); - scoutfs_key_copy_or_zeros(&__entry->last, last); - scoutfs_key_copy_or_zeros(&__entry->next, next); + sk_trace_assign(rng_start, rng_start); + sk_trace_assign(rng_end, rng_end); + sk_trace_assign(item, item); + sk_trace_assign(prev, prev); + sk_trace_assign(first, first); + sk_trace_assign(last, last); + sk_trace_assign(next, next); ), TP_printk("sb %p rng_start "SK_FMT" rng_end "SK_FMT" item "SK_FMT" prev "SK_FMT" first "SK_FMT" last "SK_FMT" next "SK_FMT, - __entry->sb, SK_ARG(&__entry->rng_start), - SK_ARG(&__entry->rng_end), SK_ARG(&__entry->item), - SK_ARG(&__entry->prev), SK_ARG(&__entry->first), - SK_ARG(&__entry->last), SK_ARG(&__entry->next)) + __entry->sb, sk_trace_args(rng_start), + sk_trace_args(rng_end), sk_trace_args(item), + sk_trace_args(prev), sk_trace_args(first), + sk_trace_args(last), sk_trace_args(next)) ); TRACE_EVENT(scoutfs_rename, diff --git a/kmod/src/super.c b/kmod/src/super.c index 6b853766..aaea4cba 100644 --- a/kmod/src/super.c +++ b/kmod/src/super.c @@ -419,7 +419,6 @@ static int __init scoutfs_module_init(void) ".string \""SCOUTFS_GIT_DESCRIBE"\\n\"\n" ".previous\n"); - scoutfs_key_init(); scoutfs_init_counters(); ret = scoutfs_sysfs_init();