mirrors/scoutfs
1
0
Fork 0
mirror of https://github.com/versity/scoutfs.git synced 2026-04-25 07:46:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

scoutfs: trace key struct

Browse Source 
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 <zab@versity.com>
This commit is contained in:
Zach Brown
2018-06-26 14:54:08 -07:00
committed by Zach Brown
parent 5935a3f43e
commit dfac36a9aa
5 changed files with 125 additions and 173 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
kmod/src/Makefile
View File

@@ -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

58
kmod/src/key.c
View File

@@ -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 <linux/kernel.h>
#include <linux/bug.h>
#include <linux/errno.h>
#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;
}

71
kmod/src/key.h
View File

@@ -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;

166
kmod/src/scoutfs_trace.h
View File

@@ -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,

1
kmod/src/super.c
View File

@@ -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();