From e6918187568dbd01842d8d1d2c808ce16a894239 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 21 Apr 2024 13:54:28 +0200 Subject: Adding upstream version 18.2.2. Signed-off-by: Daniel Baumann --- src/tracing/.gitignore | 6 + src/tracing/CMakeLists.txt | 66 + src/tracing/README.md | 51 + src/tracing/bluestore.c | 5 + src/tracing/bluestore.tp | 148 ++ src/tracing/cyg_profile.c | 6 + src/tracing/cyg_profile.tp | 23 + src/tracing/cyg_profile_functions.c | 31 + src/tracing/eventtrace.c | 5 + src/tracing/eventtrace.tp | 61 + src/tracing/librados.c | 6 + src/tracing/librados.tp | 4127 +++++++++++++++++++++++++++++++++++ src/tracing/librbd.c | 6 + src/tracing/librbd.tp | 2932 +++++++++++++++++++++++++ src/tracing/objectstore.c | 6 + src/tracing/objectstore.tp | 800 +++++++ src/tracing/oprequest.c | 6 + src/tracing/oprequest.tp | 47 + src/tracing/osd.c | 6 + src/tracing/osd.tp | 836 +++++++ src/tracing/pg.c | 6 + src/tracing/pg.tp | 18 + src/tracing/rgw_op.c | 6 + src/tracing/rgw_op.tp | 36 + src/tracing/rgw_rados.c | 6 + src/tracing/rgw_rados.tp | 50 + src/tracing/tracing-common.h | 102 + 27 files changed, 9398 insertions(+) create mode 100644 src/tracing/.gitignore create mode 100644 src/tracing/CMakeLists.txt create mode 100644 src/tracing/README.md create mode 100644 src/tracing/bluestore.c create mode 100644 src/tracing/bluestore.tp create mode 100644 src/tracing/cyg_profile.c create mode 100644 src/tracing/cyg_profile.tp create mode 100644 src/tracing/cyg_profile_functions.c create mode 100644 src/tracing/eventtrace.c create mode 100644 src/tracing/eventtrace.tp create mode 100644 src/tracing/librados.c create mode 100644 src/tracing/librados.tp create mode 100644 src/tracing/librbd.c create mode 100644 src/tracing/librbd.tp create mode 100644 src/tracing/objectstore.c create mode 100644 src/tracing/objectstore.tp create mode 100644 src/tracing/oprequest.c create mode 100644 src/tracing/oprequest.tp create mode 100644 src/tracing/osd.c create mode 100644 src/tracing/osd.tp create mode 100644 src/tracing/pg.c create mode 100644 src/tracing/pg.tp create mode 100644 src/tracing/rgw_op.c create mode 100644 src/tracing/rgw_op.tp create mode 100644 src/tracing/rgw_rados.c create mode 100644 src/tracing/rgw_rados.tp create mode 100644 src/tracing/tracing-common.h (limited to 'src/tracing') diff --git a/src/tracing/.gitignore b/src/tracing/.gitignore new file mode 100644 index 000000000..d7b78e9f1 --- /dev/null +++ b/src/tracing/.gitignore @@ -0,0 +1,6 @@ +librados.h +librbd.h +objectstore.h +oprequest.h +osd.h +pg.h diff --git a/src/tracing/CMakeLists.txt b/src/tracing/CMakeLists.txt new file mode 100644 index 000000000..0044299a4 --- /dev/null +++ b/src/tracing/CMakeLists.txt @@ -0,0 +1,66 @@ +# we are in "src/tracing", so create the output dir manually. +# the source files include the tracing headers like +# #include "tracing/oprequest.h". so better put them into +# ${PROJECT_BINARY_DIR}/include, where acconfig.h is also located +set(working_dir ${CMAKE_BINARY_DIR}/include) +set(header_dir ${working_dir}/tracing) +file(MAKE_DIRECTORY ${header_dir}) + +add_custom_target(tracepoint_libraries) + +file(GLOB tps "*.tp") +foreach(tp ${tps}) + get_filename_component(name ${tp} NAME_WE) + set(header ${header_dir}/${name}.h) + add_custom_command( + OUTPUT ${header} + COMMAND ${LTTNG_GEN_TP} ${tp} -o tracing/${name}.h + DEPENDS ${tp} + WORKING_DIRECTORY ${working_dir} + COMMENT "generating ${header}") + add_custom_target( + ${name}-tp + DEPENDS ${header}) +endforeach() + +function(add_tracing_library name tracings version) + foreach(tp_file ${tracings}) + get_filename_component(tp ${tp_file} NAME_WE) + list(APPEND hdrs + ${header_dir}/${tp}.h) + list(APPEND tpfiles ${tp}.c) + endforeach() + add_library(${name} SHARED ${hdrs} ${tpfiles}) + target_link_libraries(${name} ${LTTNGUST_LIBRARIES} ${CMAKE_DL_LIBS}) + string(REGEX MATCH "^[0-9]+" soversion ${version}) + set_target_properties(${name} PROPERTIES + OUTPUT_NAME ${name} + VERSION ${version} + SOVERSION ${soversion} + INSTALL_RPATH "") + add_dependencies(tracepoint_libraries ${name}) +endfunction() + +set(osd_traces oprequest.tp osd.tp pg.tp) +add_tracing_library(osd_tp "${osd_traces}" 1.0.0) +add_tracing_library(rados_tp librados.tp 2.0.0) +add_tracing_library(os_tp objectstore.tp 1.0.0) +add_tracing_library(bluestore_tp bluestore.tp 1.0.0) +add_tracing_library(rgw_op_tp rgw_op.tp 2.0.0) +add_tracing_library(rgw_rados_tp rgw_rados.tp 2.0.0) + +install(TARGETS rados_tp osd_tp os_tp rgw_rados_tp rgw_op_tp DESTINATION ${CMAKE_INSTALL_LIBDIR}) +if(WITH_RBD) + add_tracing_library(rbd_tp librbd.tp 1.0.0) + install(TARGETS rbd_tp DESTINATION ${CMAKE_INSTALL_LIBDIR}) +endif(WITH_RBD) +if(WITH_OSD_INSTRUMENT_FUNCTIONS) + add_tracing_library(cyg_profile_tp cyg_profile.tp 1.0.0) + install(TARGETS cyg_profile_tp DESTINATION ${CMAKE_INSTALL_LIBDIR}) +endif() + +if(WITH_EVENTTRACE) + add_tracing_library(eventtrace_tp eventtrace.tp 1.0.0) + install(TARGETS eventtrace_tp DESTINATION ${CMAKE_INSTALL_LIBDIR}) +endif() + diff --git a/src/tracing/README.md b/src/tracing/README.md new file mode 100644 index 000000000..32ec17f4d --- /dev/null +++ b/src/tracing/README.md @@ -0,0 +1,51 @@ +Installation +============ + +The LTTng libraries that ship with Ubuntu 12.04 have been very buggy, and the +generated header files using `lttng-gen-tp` have needed to be fixed just to +compile in the Ceph tree. The packages available in Ubuntu 14.04 seem to work +alright, and for older versions please install LTTng from the LTTng PPA. + + https://launchpad.net/~lttng/+archive/ppa + +Then install as normal + + apt-get install lttng-tools liblttng-ust-dev + +Add/Update Provider +=================== + +## Create tracepoint definition file + +Add tracepoint definitions for the provider into a `.tp` file. Documentation +on defining a tracepoint can be found in `man lttng-ust`. By convention files +are named according to the logical sub-system they correspond to (e.g. +`mutex.tp`, `pg.tp`). And add a C source file to be compiled into the tracepoint +provider shared object, in which `TRACEPOINT_DEFINE` should be defined. See +[LTTng document](http://lttng.org/docs/#doc-dynamic-linking) for details. +Place the `.tp` and the `.c` files into the `src/tracing` directory +and modify the CMake file `src/tracing/CMakeLists.txt` accordingly. + +Function Instrumentation +======================== +Ceph supports instrumentation using GCC's `-finstrument-functions` flag. +Supported CMake flags are: + +* `-DWITH_OSD_INSTRUMENT_FUNCTIONS=ON`: instrument OSD code + +Note that this instrumentation adds an extra function call on each function entry +and exit of Ceph code. This option is currently only supported with GCC. Using it +with Clang has no effect. + +The only function tracing implementation at the moment is done using LTTng UST. +In order to use it, Ceph needs to be configured with LTTng using `-DWITH_LTTNG=ON`. +[TraceCompass](http://www.tracecompass.org) can be used to generate flame +charts/graphs and other metrics. + +It is also possible to use [libbabeltrace](http://diamon.org/babeltrace/#docs) +to write custom analysis. The entry and exit tracepoints are called +`lttng_ust_cyg_profile:func_enter` and `lttng_ust_cyg_profile:func_exit` +respectively. The payload variable `addr` holds the address of the function +called and the payload variable `call_site` holds the address where it is called. +`nm` can be used to resolve function addresses (`addr` to function name). + diff --git a/src/tracing/bluestore.c b/src/tracing/bluestore.c new file mode 100644 index 000000000..25984b9df --- /dev/null +++ b/src/tracing/bluestore.c @@ -0,0 +1,5 @@ +#define TRACEPOINT_CREATE_PROBES +/* + * The header containing our TRACEPOINT_EVENTs. + */ +#include "tracing/bluestore.h" diff --git a/src/tracing/bluestore.tp b/src/tracing/bluestore.tp new file mode 100644 index 000000000..41466f166 --- /dev/null +++ b/src/tracing/bluestore.tp @@ -0,0 +1,148 @@ +#include "include/int_types.h" + +TRACEPOINT_EVENT(bluestore, transaction_state_duration, + TP_ARGS( + uint32_t, sequencer_id, + uint64_t, tid, + uint8_t, state, + double, elapsed), + TP_FIELDS( + ctf_integer(uint32_t, sequencer_id, sequencer_id) + ctf_integer(uint64_t, tid, tid) + ctf_integer(int8_t, state, state) + ctf_float(double, elapsed, elapsed) + ) +) + +TRACEPOINT_EVENT(bluestore, transaction_total_duration, + TP_ARGS( + uint32_t, sequencer_id, + uint64_t, tid, + double, elapsed), + TP_FIELDS( + ctf_integer(uint32_t, sequencer_id, sequencer_id) + ctf_integer(uint64_t, tid, tid) + ctf_float(double, elapsed, elapsed) + ) +) + +TRACEPOINT_EVENT(bluestore, transaction_commit_latency, + TP_ARGS( + uint32_t, sequencer_id, + uint64_t, tid, + double, elapsed), + TP_FIELDS( + ctf_integer(uint32_t, sequencer_id, sequencer_id) + ctf_integer(uint64_t, tid, tid) + ctf_float(double, elapsed, elapsed) + ) +) + +TRACEPOINT_EVENT(bluestore, transaction_kv_submit_latency, + TP_ARGS( + uint32_t, sequencer_id, + uint64_t, tid, + uint8_t, sync, + double, elapsed), + TP_FIELDS( + ctf_integer(uint32_t, sequencer_id, sequencer_id) + ctf_integer(uint64_t, tid, tid) + ctf_integer(int8_t, sync, sync) + ctf_float(double, elapsed, elapsed) + ) +) + +TRACEPOINT_EVENT(bluestore, transaction_kv_sync_latency, + TP_ARGS( + uint32_t, sequencer_id, + uint64_t, tid, + uint32_t, kv_batch_size, + uint32_t, deferred_done_batch_size, + uint32_t, deferred_stable_batch_size, + double, elapsed), + TP_FIELDS( + ctf_integer(uint32_t, sequencer_id, sequencer_id) + ctf_integer(uint64_t, tid, tid) + ctf_integer(uint32_t, kv_batch_size, kv_batch_size) + ctf_integer(uint32_t, deferred_done_batch_size, deferred_done_batch_size) + ctf_integer(uint32_t, deferred_stable_batch_size, deferred_stable_batch_size) + ctf_float(double, elapsed, elapsed) + ) +) + +TRACEPOINT_EVENT(bluestore, transaction_initial_state, + TP_ARGS( + uint32_t, sequencer_id, + uint64_t, tid, + int64_t, current_kv_throttle_cost, + int64_t, current_deferred_throttle_cost, + uint64_t, pending_kv_ios, + uint64_t, pending_deferred_ios, + uint64_t, ios_started_since_last_traced_io, + uint64_t, ios_completed_since_last_traced_io, + double, throttle_time), + TP_FIELDS( + ctf_integer(uint32_t, sequencer_id, sequencer_id) + ctf_integer(uint64_t, tid, tid) + ctf_integer(int64_t, current_kv_throttle_cost, current_kv_throttle_cost) + ctf_integer(int64_t, current_deferred_throttle_cost, current_deferred_throttle_cost) + ctf_integer(uint64_t, pending_kv_ios, pending_kv_ios) + ctf_integer(uint64_t, pending_deferred_ios, pending_deferred_ios) + ctf_integer(uint64_t, ios_started_since_last_traced_io, ios_started_since_last_traced_io) + ctf_integer(uint64_t, ios_completed_since_last_traced_io, ios_completed_since_last_traced_io) + ctf_float(double, throttle_time, throttle_time) + ) +) + +TRACEPOINT_EVENT(bluestore, transaction_initial_state_rocksdb, + TP_ARGS( + uint32_t, sequencer_id, + uint64_t, tid, + uint64_t, rocksdb_base_level, + uint64_t, rocksdb_estimate_pending_compaction_bytes, + uint64_t, rocksdb_cur_size_all_mem_tables, + uint64_t, rocksdb_compaction_pending, + uint64_t, rocksdb_mem_table_flush_pending, + uint64_t, rocksdb_num_running_compactions, + uint64_t, rocksdb_num_running_flushes, + uint64_t, rocksdb_actual_delayed_write_rate), + TP_FIELDS( + ctf_integer(uint32_t, sequencer_id, sequencer_id) + ctf_integer(uint64_t, tid, tid) + ctf_integer(uint64_t, rocksdb_base_level, rocksdb_base_level) + ctf_integer(uint64_t, rocksdb_estimate_pending_compaction_bytes, rocksdb_estimate_pending_compaction_bytes) + ctf_integer(uint64_t, rocksdb_cur_size_all_mem_tables, rocksdb_cur_size_all_mem_tables) + ctf_integer(uint64_t, rocksdb_compaction_pending,rocksdb_compaction_pending) + ctf_integer(uint64_t, rocksdb_mem_table_flush_pending, rocksdb_mem_table_flush_pending) + ctf_integer(uint64_t, rocksdb_num_running_compactions, rocksdb_num_running_compactions) + ctf_integer(uint64_t, rocksdb_num_running_flushes, rocksdb_num_running_flushes) + ctf_integer(uint64_t, rocksdb_actual_delayed_write_rate, rocksdb_actual_delayed_write_rate) + ) +) + +TRACEPOINT_EVENT(bluestore, kv_submit, + TP_ARGS( + uint32_t, sequencer_id, + uint64_t, tid, + uint64_t, rocksdb_base_level, + uint64_t, rocksdb_estimate_pending_compaction_bytes, + uint64_t, rocksdb_cur_size_all_mem_tables, + uint64_t, rocksdb_compaction_pending, + uint64_t, rocksdb_mem_table_flush_pending, + uint64_t, rocksdb_num_running_compactions, + uint64_t, rocksdb_num_running_flushes, + uint64_t, rocksdb_actual_delayed_write_rate), + TP_FIELDS( + ctf_integer(uint32_t, sequencer_id, sequencer_id) + ctf_integer(uint64_t, tid, tid) + ctf_integer(uint64_t, rocksdb_base_level, rocksdb_base_level) + ctf_integer(uint64_t, rocksdb_estimate_pending_compaction_bytes, rocksdb_estimate_pending_compaction_bytes) + ctf_integer(uint64_t, rocksdb_cur_size_all_mem_tables, rocksdb_cur_size_all_mem_tables) + ctf_integer(uint64_t, rocksdb_compaction_pending,rocksdb_compaction_pending) + ctf_integer(uint64_t, rocksdb_mem_table_flush_pending, rocksdb_mem_table_flush_pending) + ctf_integer(uint64_t, rocksdb_num_running_compactions, rocksdb_num_running_compactions) + ctf_integer(uint64_t, rocksdb_num_running_flushes, rocksdb_num_running_flushes) + ctf_integer(uint64_t, rocksdb_actual_delayed_write_rate, rocksdb_actual_delayed_write_rate) + ) +) + diff --git a/src/tracing/cyg_profile.c b/src/tracing/cyg_profile.c new file mode 100644 index 000000000..c55272117 --- /dev/null +++ b/src/tracing/cyg_profile.c @@ -0,0 +1,6 @@ +#define TRACEPOINT_CREATE_PROBES +/* + * The header containing our TRACEPOINT_EVENTs. + */ +#include "tracing/cyg_profile.h" + diff --git a/src/tracing/cyg_profile.tp b/src/tracing/cyg_profile.tp new file mode 100644 index 000000000..42d9b4c92 --- /dev/null +++ b/src/tracing/cyg_profile.tp @@ -0,0 +1,23 @@ +#include "include/int_types.h" + +TRACEPOINT_EVENT(lttng_ust_cyg_profile, func_entry, + TP_ARGS( + void *, func_addr, + void *, call_site), + TP_FIELDS( + ctf_integer_hex(unsigned long, addr, func_addr) + ctf_integer_hex(unsigned long, call_site, call_site) + ) +) + +TRACEPOINT_EVENT(lttng_ust_cyg_profile, func_exit, + TP_ARGS( + void *, func_addr, + void *, call_site + ), + TP_FIELDS( + ctf_integer_hex(unsigned long, addr, func_addr) + ctf_integer_hex(unsigned long, call_site, call_site) + ) +) + diff --git a/src/tracing/cyg_profile_functions.c b/src/tracing/cyg_profile_functions.c new file mode 100644 index 000000000..d09c14c9d --- /dev/null +++ b/src/tracing/cyg_profile_functions.c @@ -0,0 +1,31 @@ +#include "acconfig.h" + +#ifdef WITH_LTTNG +#define TRACEPOINT_DEFINE +#define TRACEPOINT_PROBE_DYNAMIC_LINKAGE +#include "tracing/cyg_profile.h" +#undef TRACEPOINT_PROBE_DYNAMIC_LINKAGE +#undef TRACEPOINT_DEFINE +#endif + +void __cyg_profile_func_enter(void *this_fn, void *call_site) + __attribute__((no_instrument_function)); + +void __cyg_profile_func_exit(void *this_fn, void *call_site) + __attribute__((no_instrument_function)); + + +void __cyg_profile_func_enter(void *this_fn, void *call_site) +{ +#ifdef WITH_LTTNG + tracepoint(lttng_ust_cyg_profile, func_entry, this_fn, call_site); +#endif +} + +void __cyg_profile_func_exit(void *this_fn, void *call_site) +{ +#ifdef WITH_LTTNG + tracepoint(lttng_ust_cyg_profile, func_exit, this_fn, call_site); +#endif +} + diff --git a/src/tracing/eventtrace.c b/src/tracing/eventtrace.c new file mode 100644 index 000000000..54ebae020 --- /dev/null +++ b/src/tracing/eventtrace.c @@ -0,0 +1,5 @@ +#define TRACEPOINT_CREATE_PROBES +/* + * The header containing our TRACEPOINT_EVENTs. + */ +#include "tracing/eventtrace.h" diff --git a/src/tracing/eventtrace.tp b/src/tracing/eventtrace.tp new file mode 100644 index 000000000..f28ded100 --- /dev/null +++ b/src/tracing/eventtrace.tp @@ -0,0 +1,61 @@ +#include "include/int_types.h" + +TRACEPOINT_EVENT(eventtrace, func_enter, + TP_ARGS( + const char*, file, + const char*, func, + uint32_t, line), + TP_FIELDS( + ctf_string(file, file) + ctf_string(func, func) + ctf_integer(uint32_t, line, line) + ) +) + +TRACEPOINT_EVENT(eventtrace, func_exit, + TP_ARGS( + const char*, file, + const char*, func), + TP_FIELDS( + ctf_string(file, file) + ctf_string(func, func) + ) +) + +TRACEPOINT_EVENT(eventtrace, oid_event, + TP_ARGS( + const char*, oid, + const char*, event, + const char*, context, + const char*, file, + const char*, func, + uint32_t, line), + TP_FIELDS( + ctf_string(oid, oid) + ctf_string(event, event) + ctf_string(context, context) + ctf_string(file, file) + ctf_string(func, func) + ctf_integer(uint32_t, line, line) + ) +) + +TRACEPOINT_EVENT(eventtrace, oid_elapsed, + TP_ARGS( + const char*, oid, + const char*, event, + const char*, context, + double, elapsed, + const char*, file, + const char*, func, + uint32_t, line), + TP_FIELDS( + ctf_string(oid, oid) + ctf_string(event, event) + ctf_string(context, context) + ctf_float(double, elapsed, elapsed) + ctf_string(file, file) + ctf_string(func, func) + ctf_integer(uint32_t, line, line) + ) +) diff --git a/src/tracing/librados.c b/src/tracing/librados.c new file mode 100644 index 000000000..ae25f3e3b --- /dev/null +++ b/src/tracing/librados.c @@ -0,0 +1,6 @@ + +#define TRACEPOINT_CREATE_PROBES +/* + * The header containing our TRACEPOINT_EVENTs. + */ +#include "tracing/librados.h" diff --git a/src/tracing/librados.tp b/src/tracing/librados.tp new file mode 100644 index 000000000..8b5e78ef1 --- /dev/null +++ b/src/tracing/librados.tp @@ -0,0 +1,4127 @@ +#include "tracing/tracing-common.h" +#include "include/rados/librados.h" +#include "include/int_types.h" + +TRACEPOINT_EVENT(librados, rados_create_enter, + TP_ARGS( + const char*, id), + TP_FIELDS( + ceph_ctf_string(id, id) + ) +) + +TRACEPOINT_EVENT(librados, rados_create_exit, + TP_ARGS( + int, retval, + rados_t, cluster), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer_hex(rados_t, cluster, cluster) + ) +) + +TRACEPOINT_EVENT(librados, rados_create2_enter, + TP_ARGS( + const char*, clustername, + const char*, name, + uint64_t, flags), + TP_FIELDS( + ceph_ctf_string(clustername, clustername) + ceph_ctf_string(name, name) + ctf_integer_hex(uint64_t, flags, flags) + ) +) + +TRACEPOINT_EVENT(librados, rados_create2_exit, + TP_ARGS( + int, retval, + rados_t, cluster), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer_hex(rados_t, cluster, cluster) + ) +) + +TRACEPOINT_EVENT(librados, rados_create_with_context_enter, + TP_ARGS( + rados_config_t, cct), + TP_FIELDS( + ctf_integer_hex(rados_config_t, cct, cct) + ) +) + +TRACEPOINT_EVENT(librados, rados_create_with_context_exit, + TP_ARGS( + int, retval, + rados_t, cluster), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer_hex(rados_t, cluster, cluster) + ) +) + +TRACEPOINT_EVENT(librados, rados_cct_enter, + TP_ARGS( + rados_t, cluster), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ) +) + +TRACEPOINT_EVENT(librados, rados_cct_exit, + TP_ARGS( + rados_config_t, retval), + TP_FIELDS( + ctf_integer_hex(rados_config_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_connect_enter, + TP_ARGS( + rados_t, cluster), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ) +) + +TRACEPOINT_EVENT(librados, rados_connect_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_shutdown_enter, + TP_ARGS( + rados_t, cluster), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ) +) + +TRACEPOINT_EVENT(librados, rados_shutdown_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_get_instance_id_enter, + TP_ARGS( + rados_t, cluster), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ) +) + +TRACEPOINT_EVENT(librados, rados_get_instance_id_exit, + TP_ARGS( + uint64_t, retval), + TP_FIELDS( + ctf_integer(uint64_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_version_enter, + TP_ARGS( + int*, pmajor, + int*, pminor, + int*, pextra), + TP_FIELDS( + ctf_integer_hex(int*, pmajor, pmajor) + ctf_integer_hex(int*, pminor, pminor) + ctf_integer_hex(int*, pextra, pextra) + ) +) + +TRACEPOINT_EVENT(librados, rados_version_exit, + TP_ARGS( + int, major, + int, minor, + int, extra), + TP_FIELDS( + ctf_integer(int, major, major) + ctf_integer(int, minor, minor) + ctf_integer(int, extra, extra) + ) +) + +TRACEPOINT_EVENT(librados, rados_conf_read_file_enter, + TP_ARGS( + rados_t, cluster, + const char*, path_list), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ceph_ctf_string(path_list, path_list) + ) +) + +TRACEPOINT_EVENT(librados, rados_conf_read_file_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_conf_parse_argv_enter, + TP_ARGS( + rados_t, cluster, + int, argc), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_integer(int, argc, argc) + ) +) + +TRACEPOINT_EVENT(librados, rados_conf_parse_argv_arg, + TP_ARGS( + const char*, arg), + TP_FIELDS( + ceph_ctf_string(arg, arg) + ) +) + +TRACEPOINT_EVENT(librados, rados_conf_parse_argv_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_conf_parse_argv_remainder_enter, + TP_ARGS( + rados_t, cluster, + int, argc), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_integer(int, argc, argc) + ) +) + +TRACEPOINT_EVENT(librados, rados_conf_parse_argv_remainder_arg, + TP_ARGS( + const char*, arg), + TP_FIELDS( + ceph_ctf_string(arg, arg) + ) +) + +TRACEPOINT_EVENT(librados, rados_conf_parse_argv_remainder_remarg, + TP_ARGS( + const char*, remarg), + TP_FIELDS( + ceph_ctf_string(remarg, remarg) + ) +) + +TRACEPOINT_EVENT(librados, rados_conf_parse_argv_remainder_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_conf_parse_env_enter, + TP_ARGS( + rados_t, cluster, + const char*, env), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_string(env, env) + ) +) + +TRACEPOINT_EVENT(librados, rados_conf_parse_env_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_conf_set_enter, + TP_ARGS( + rados_t, cluster, + const char*, option, + const char*, value), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ceph_ctf_string(option, option) + ceph_ctf_string(value, value) + ) +) + +TRACEPOINT_EVENT(librados, rados_conf_set_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_cluster_stat_enter, + TP_ARGS( + rados_t, cluster), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ) +) + +TRACEPOINT_EVENT(librados, rados_cluster_stat_exit, + TP_ARGS( + int, retval, + uint64_t, kb, + uint64_t, kb_used, + uint64_t, kb_avail, + uint64_t, num_objects), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(uint64_t, kb, kb) + ctf_integer(uint64_t, kb_used, kb_used) + ctf_integer(uint64_t, kb_avail, kb_avail) + ctf_integer(uint64_t, num_objects, num_objects) + ) +) + +TRACEPOINT_EVENT(librados, rados_conf_get_enter, + TP_ARGS( + rados_t, cluster, + const char*, option, + size_t, len), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_string(option, option) + ctf_integer(size_t, len, len) + ) +) + +TRACEPOINT_EVENT(librados, rados_conf_get_exit, + TP_ARGS( + int, retval, + const char*, value), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_string(value, value) + ) +) + +TRACEPOINT_EVENT(librados, rados_pool_lookup_enter, + TP_ARGS( + rados_t, cluster, + const char*, name), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_string(name, name) + ) +) + +TRACEPOINT_EVENT(librados, rados_pool_lookup_exit, + TP_ARGS( + int64_t, retval), + TP_FIELDS( + ctf_integer(int64_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_pool_reverse_lookup_enter, + TP_ARGS( + rados_t, cluster, + int64_t, id, + size_t, maxlen), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_integer(int64_t, id, id) + ctf_integer(size_t, maxlen, maxlen) + ) +) + +TRACEPOINT_EVENT(librados, rados_pool_reverse_lookup_exit, + TP_ARGS( + int, retval, + const char*, name), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_string(name, name) + ) +) + +TRACEPOINT_EVENT(librados, rados_cluster_fsid_enter, + TP_ARGS( + rados_t, cluster, + size_t, maxlen), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_integer(size_t, maxlen, maxlen) + ) +) + +TRACEPOINT_EVENT(librados, rados_cluster_fsid_exit, + TP_ARGS( + int, retval, + const char*, fsid), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_string(fsid, fsid) + ) +) + +TRACEPOINT_EVENT(librados, rados_wait_for_latest_osdmap_enter, + TP_ARGS( + rados_t, cluster), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ) +) + +TRACEPOINT_EVENT(librados, rados_wait_for_latest_osdmap_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_pool_list_enter, + TP_ARGS( + rados_t, cluster, + size_t, maxlen), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_integer(size_t, maxlen, maxlen) + ) +) + +TRACEPOINT_EVENT(librados, rados_pool_list_pool, + TP_ARGS( + const char*, buf), + TP_FIELDS( + ctf_string(buf, buf) + ) +) + +TRACEPOINT_EVENT(librados, rados_pool_list_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_ping_monitor_enter, + TP_ARGS( + rados_t, cluster, + const char*, mon_id), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_string(mon_id, mon_id) + ) +) + +TRACEPOINT_EVENT(librados, rados_ping_monitor_exit, + TP_ARGS( + int, retval, + char const* const*, buf, + size_t*, len), + TP_FIELDS( + ctf_integer(int, retval, retval) + ceph_ctf_sequencep(unsigned char, buf, buf, size_t, len) + ) +) + +TRACEPOINT_EVENT(librados, rados_mon_command_enter, + TP_ARGS( + rados_t, cluster, + size_t, cmdlen, + const char*, inbuf, + size_t, inbuflen), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_integer(size_t, cmdlen, cmdlen) + ceph_ctf_sequence(unsigned char, inbuf, inbuf, size_t, inbuflen) + ) +) + +TRACEPOINT_EVENT(librados, rados_mon_command_cmd, + TP_ARGS( + const char*, cmd), + TP_FIELDS( + ctf_string(cmd, cmd) + ) +) + +TRACEPOINT_EVENT(librados, rados_mon_command_exit, + TP_ARGS( + int, retval, + char**, outbuf, + size_t*, outbuflen, + char**, outs, + size_t*, outslen), + TP_FIELDS( + ctf_integer(int, retval, retval) + ceph_ctf_stringp(outs, outs) + ceph_ctf_sequencep(unsigned char, outbuf, outbuf, size_t, outbuflen) + ceph_ctf_integerp(size_t, outslen, outslen) + ) +) + +TRACEPOINT_EVENT(librados, rados_mon_command_target_enter, + TP_ARGS( + rados_t, cluster, + const char*, name, + size_t, cmdlen, + const char*, inbuf, + size_t, inbuflen), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_string(name, name) + ctf_integer(size_t, cmdlen, cmdlen) + ceph_ctf_sequence(unsigned char, inbuf, inbuf, size_t, inbuflen) + ) +) + +TRACEPOINT_EVENT(librados, rados_mon_command_target_cmd, + TP_ARGS( + const char*, cmd), + TP_FIELDS( + ctf_string(cmd, cmd) + ) +) + +TRACEPOINT_EVENT(librados, rados_mon_command_target_exit, + TP_ARGS( + int, retval, + char**, outbuf, + size_t*, outbuflen, + char**, outs, + size_t*, outslen), + TP_FIELDS( + ctf_integer(int, retval, retval) + ceph_ctf_stringp(outs, outs) + ceph_ctf_sequencep(unsigned char, outbuf, outbuf, size_t, outbuflen) + ceph_ctf_integerp(size_t, outslen, outslen) + ) +) + +TRACEPOINT_EVENT(librados, rados_osd_command_enter, + TP_ARGS( + rados_t, cluster, + int, osdid, + size_t, cmdlen, + const char*, inbuf, + size_t, inbuflen), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_integer(int, osdid, osdid) + ctf_integer(size_t, cmdlen, cmdlen) + ceph_ctf_sequence(unsigned char, inbuf, inbuf, size_t, inbuflen) + ) +) + +TRACEPOINT_EVENT(librados, rados_osd_command_cmd, + TP_ARGS( + const char*, cmd), + TP_FIELDS( + ctf_string(cmd, cmd) + ) +) + +TRACEPOINT_EVENT(librados, rados_osd_command_exit, + TP_ARGS( + int, retval, + char**, outbuf, + size_t*, outbuflen, + char**, outs, + size_t*, outslen), + TP_FIELDS( + ctf_integer(int, retval, retval) + ceph_ctf_stringp(outs, outs) + ceph_ctf_sequencep(unsigned char, outbuf, outbuf, size_t, outbuflen) + ceph_ctf_integerp(size_t, outslen, outslen) + ) +) + +TRACEPOINT_EVENT(librados, rados_mgr_command_enter, + TP_ARGS( + rados_t, cluster, + size_t, cmdlen, + const char*, inbuf, + size_t, inbuflen), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_integer(size_t, cmdlen, cmdlen) + ceph_ctf_sequence(unsigned char, inbuf, inbuf, size_t, inbuflen) + ) +) + +TRACEPOINT_EVENT(librados, rados_mgr_command_cmd, + TP_ARGS( + const char*, cmd), + TP_FIELDS( + ctf_string(cmd, cmd) + ) +) + +TRACEPOINT_EVENT(librados, rados_mgr_command_exit, + TP_ARGS( + int, retval, + char**, outbuf, + size_t*, outbuflen, + char**, outs, + size_t*, outslen), + TP_FIELDS( + ctf_integer(int, retval, retval) + ceph_ctf_stringp(outs, outs) + ceph_ctf_sequencep(unsigned char, outbuf, outbuf, size_t, outbuflen) + ceph_ctf_integerp(size_t, outslen, outslen) + ) +) + +TRACEPOINT_EVENT(librados, rados_mgr_command_target_enter, + TP_ARGS( + rados_t, cluster, + const char *, name, + size_t, cmdlen, + const char*, inbuf, + size_t, inbuflen), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_string(name, name) + ctf_integer(size_t, cmdlen, cmdlen) + ceph_ctf_sequence(unsigned char, inbuf, inbuf, size_t, inbuflen) + ) +) + +TRACEPOINT_EVENT(librados, rados_mgr_command_target_cmd, + TP_ARGS( + const char*, cmd), + TP_FIELDS( + ctf_string(cmd, cmd) + ) +) + +TRACEPOINT_EVENT(librados, rados_mgr_command_target_exit, + TP_ARGS( + int, retval, + char**, outbuf, + size_t*, outbuflen, + char**, outs, + size_t*, outslen), + TP_FIELDS( + ctf_integer(int, retval, retval) + ceph_ctf_stringp(outs, outs) + ceph_ctf_sequencep(unsigned char, outbuf, outbuf, size_t, outbuflen) + ceph_ctf_integerp(size_t, outslen, outslen) + ) +) + +TRACEPOINT_EVENT(librados, rados_pg_command_enter, + TP_ARGS( + rados_t, cluster, + const char*, pg, + size_t, cmdlen, + const char*, inbuf, + size_t, inbuflen), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_string(pg, pg) + ctf_integer(size_t, cmdlen, cmdlen) + ceph_ctf_sequence(unsigned char, inbuf, inbuf, size_t, inbuflen) + ) +) + +TRACEPOINT_EVENT(librados, rados_pg_command_cmd, + TP_ARGS( + const char*, cmd), + TP_FIELDS( + ctf_string(cmd, cmd) + ) +) + +TRACEPOINT_EVENT(librados, rados_pg_command_exit, + TP_ARGS( + int, retval, + char**, outbuf, + size_t*, outbuflen, + char**, outs, + size_t*, outslen), + TP_FIELDS( + ctf_integer(int, retval, retval) + ceph_ctf_stringp(outs, outs) + ceph_ctf_sequencep(unsigned char, outbuf, outbuf, size_t, outbuflen) + ceph_ctf_integerp(size_t, outslen, outslen) + ) +) + +TRACEPOINT_EVENT(librados, rados_buffer_free_enter, + TP_ARGS( + void*, buf), + TP_FIELDS( + ctf_integer_hex(void*, buf, buf) + ) +) + +TRACEPOINT_EVENT(librados, rados_buffer_free_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_monitor_log_enter, + TP_ARGS( + rados_t, cluster, + const char*, level, + rados_log_callback_t, callback, + void*, arg), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ceph_ctf_string(level, level) + ctf_integer_hex(rados_log_callback_t, callback, callback) + ctf_integer_hex(void*, arg, arg) + ) +) + +TRACEPOINT_EVENT(librados, rados_monitor_log_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_monitor_log2_enter, + TP_ARGS( + rados_t, cluster, + const char*, level, + rados_log_callback2_t, callback, + void*, arg), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ceph_ctf_string(level, level) + ctf_integer_hex(rados_log_callback2_t, callback, callback) + ctf_integer_hex(void*, arg, arg) + ) +) + +TRACEPOINT_EVENT(librados, rados_monitor_log2_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_create_enter, + TP_ARGS( + rados_t, cluster, + const char*, name), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_string(name, name) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_create_exit, + TP_ARGS( + int, retval, + rados_ioctx_t, ioctx), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_create2_enter, + TP_ARGS( + rados_t, cluster, + int64_t, pool_id), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_integer(int64_t, pool_id, pool_id) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_create2_exit, + TP_ARGS( + int, retval, + rados_ioctx_t, ioctx), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_destroy_enter, + TP_ARGS( + rados_ioctx_t, ioctx), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_destroy_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_ioctx_pool_stat_enter, + TP_ARGS( + rados_ioctx_t, ioctx), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_pool_stat_exit, + TP_ARGS( + int, retval, + struct rados_pool_stat_t*, stats), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(uint64_t, num_kb, stats->num_kb) + ctf_integer(uint64_t, num_bytes, stats->num_bytes) + ctf_integer(uint64_t, num_objects, stats->num_objects) + ctf_integer(uint64_t, num_object_clones, stats->num_object_clones) + ctf_integer(uint64_t, num_object_copies, stats->num_object_copies) + ctf_integer(uint64_t, num_objects_missing_on_primary, stats->num_objects_missing_on_primary) + ctf_integer(uint64_t, num_objects_unfound, stats->num_objects_unfound) + ctf_integer(uint64_t, num_objects_degraded, stats->num_objects_degraded) + ctf_integer(uint64_t, num_rd, stats->num_rd) + ctf_integer(uint64_t, num_rd_kb, stats->num_rd_kb) + ctf_integer(uint64_t, num_wr, stats->num_wr) + ctf_integer(uint64_t, num_wr_kb, stats->num_wr_kb) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_cct_enter, + TP_ARGS( + rados_ioctx_t, ioctx), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_cct_exit, + TP_ARGS( + rados_config_t, retval), + TP_FIELDS( + ctf_integer_hex(rados_config_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_snap_set_read_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + uint64_t, snapid), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_integer(uint64_t, snapid, snapid) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_snap_set_read_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_ioctx_selfmanaged_snap_set_write_ctx_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + uint64_t, seq, + uint64_t*, snaps, + int, num_snaps), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_integer(uint64_t, seq, seq) + ctf_sequence(uint64_t, snaps, snaps, + uint32_t, num_snaps) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_selfmanaged_snap_set_write_ctx_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + const void*, buf, + size_t, len, + uint64_t, off), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ceph_ctf_sequence(unsigned char, buf, buf, size_t, len) + ctf_integer(uint64_t, off, off) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_append_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + const void*, buf, + size_t, len), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ceph_ctf_sequence(unsigned char, buf, buf, size_t, len) + ) +) + +TRACEPOINT_EVENT(librados, rados_append_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_full_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + const void*, buf, + size_t, len), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ceph_ctf_sequence(unsigned char, buf, buf, size_t, len) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_full_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_writesame_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + const void*, buf, + size_t, data_len, + size_t, write_len, + uint64_t, off), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ceph_ctf_sequence(unsigned char, buf, buf, size_t, data_len) + ctf_integer(size_t, write_len, write_len) + ctf_integer(uint64_t, off, off) + ) +) + +TRACEPOINT_EVENT(librados, rados_writesame_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_trunc_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + uint64_t, size), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer(uint64_t, size, size) + ) +) + +TRACEPOINT_EVENT(librados, rados_trunc_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_remove_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ) +) + +TRACEPOINT_EVENT(librados, rados_remove_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + void*, buf, + size_t, len, + uint64_t, off), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer_hex(void*, buf, buf) + ctf_integer(size_t, len, len) + ctf_integer(size_t, off, off) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_exit, + TP_ARGS( + int, retval, + void*, buf), + TP_FIELDS( + ctf_integer(int, retval, retval) + ceph_ctf_sequence(unsigned char, buf, buf, uint64_t, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_checksum_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + int, type, + const char*, init_value, + size_t, init_value_len, + size_t, len, + uint64_t, off, + size_t, chunk_size), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer(int, type, type) + ceph_ctf_sequence(unsigned char, init_value, init_value, size_t, init_value_len) + ctf_integer(size_t, len, len) + ctf_integer(uint64_t, off, off) + ctf_integer(size_t, chunk_size, chunk_size) + ) +) + +TRACEPOINT_EVENT(librados, rados_checksum_exit, + TP_ARGS( + int, retval, + const char*, checksum, + size_t, checksum_len + ), + TP_FIELDS( + ctf_integer(int, retval, retval) + ceph_ctf_sequence(unsigned char, checksum, checksum, size_t, checksum_len) + ) +) + +TRACEPOINT_EVENT(librados, rados_get_last_version_enter, + TP_ARGS( + rados_ioctx_t, ioctx), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_get_last_version_exit, + TP_ARGS( + uint64_t, retval), + TP_FIELDS( + ctf_integer(uint64_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_pool_create_enter, + TP_ARGS( + rados_t, cluster, + const char*, name), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_string(name, name) + ) +) + +TRACEPOINT_EVENT(librados, rados_pool_create_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_pool_create_with_auid_enter, + TP_ARGS( + rados_t, cluster, + const char*, name, + uint64_t, auid), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_string(name, name) + ctf_integer(uint64_t, auid, auid) + ) +) + +TRACEPOINT_EVENT(librados, rados_pool_create_with_auid_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_pool_create_with_crush_rule_enter, + TP_ARGS( + rados_t, cluster, + const char*, name, + uint8_t, crush_rule_num), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_string(name, name) + ctf_integer(uint8_t, crush_rule_num, crush_rule_num) + ) +) + +TRACEPOINT_EVENT(librados, rados_pool_create_with_crush_rule_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_pool_create_with_all_enter, + TP_ARGS( + rados_t, cluster, + const char*, name, + uint64_t, auid, + uint8_t, crush_rule_num), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_string(name, name) + ctf_integer(uint64_t, auid, auid) + ctf_integer(uint8_t, crush_rule_num, crush_rule_num) + ) +) + +TRACEPOINT_EVENT(librados, rados_pool_create_with_all_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_pool_get_base_tier_enter, + TP_ARGS( + rados_t, cluster, + int64_t, pool_id), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_integer(int64_t, pool_id, pool_id) + ) +) + +TRACEPOINT_EVENT(librados, rados_pool_get_base_tier_exit, + TP_ARGS( + int, retval, + int64_t, base_tier), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(int64_t, base_tier, base_tier) + ) +) + +TRACEPOINT_EVENT(librados, rados_pool_delete_enter, + TP_ARGS( + rados_t, cluster, + const char*, name), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_string(name, name) + ) +) + +TRACEPOINT_EVENT(librados, rados_pool_delete_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_pool_set_auid_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + uint64_t, auid), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_integer(uint64_t, auid, auid) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_pool_set_auid_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_pool_get_auid_enter, + TP_ARGS( + rados_ioctx_t, ioctx), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_pool_get_auid_exit, + TP_ARGS( + int, retval, + uint64_t, auid), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(uint64_t, auid, auid) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_pool_requires_alignment_enter, + TP_ARGS( + rados_ioctx_t, ioctx), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_pool_requires_alignment_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_pool_requires_alignment_enter2, + TP_ARGS( + rados_ioctx_t, ioctx), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_pool_requires_alignment_exit2, + TP_ARGS( + int, retval, + int, req), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(int, requires, req) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_pool_required_alignment_enter, + TP_ARGS( + rados_ioctx_t, ioctx), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_pool_required_alignment_exit, + TP_ARGS( + uint64_t, retval), + TP_FIELDS( + ctf_integer(uint64_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_pool_required_alignment_enter2, + TP_ARGS( + rados_ioctx_t, ioctx), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_pool_required_alignment_exit2, + TP_ARGS( + int, retval, + uint64_t, alignment), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(uint64_t, alignment, alignment) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_locator_set_key_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, key), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ceph_ctf_string(key, key) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_locator_set_key_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_ioctx_set_namespace_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, nspace), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ceph_ctf_string(nspace, nspace) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_set_namespace_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_ioctx_get_namespace_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + unsigned, maxlen), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_integer(unsigned, maxlen, maxlen) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_get_namespace_exit, + TP_ARGS( + int, retval, + const char*, name), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_string(name, name) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_get_cluster_enter, + TP_ARGS( + rados_ioctx_t, ioctx), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_get_cluster_exit, + TP_ARGS( + rados_t, retval), + TP_FIELDS( + ctf_integer_hex(rados_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_get_id_enter, + TP_ARGS( + rados_ioctx_t, ioctx), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_get_id_exit, + TP_ARGS( + int64_t, retval), + TP_FIELDS( + ctf_integer_hex(int64_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_get_pool_name_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + unsigned, maxlen), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_integer(unsigned, maxlen, maxlen) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_get_pool_name_exit, + TP_ARGS( + int, retval, + const char*, name), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_string(name, name) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_snap_create_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, snapname), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(snapname, snapname) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_snap_create_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_snap_remove_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, snapname), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(snapname, snapname) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_snap_remove_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_snap_rollback_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + const char*, snapname), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_string(snapname, snapname) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_snap_rollback_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_selfmanaged_snap_create_enter, + TP_ARGS( + rados_ioctx_t, ioctx), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_selfmanaged_snap_create_exit, + TP_ARGS( + int, retval, + uint64_t, snapid), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(uint64_t, snapid, snapid) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_selfmanaged_snap_remove_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + uint64_t, snapid), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_integer(uint64_t, snapid, snapid) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_selfmanaged_snap_remove_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_selfmanaged_snap_rollback_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + uint64_t, snapid), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer(uint64_t, snapid, snapid) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_selfmanaged_snap_rollback_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_snap_list_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + int, maxlen), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_integer(int, maxlen, maxlen) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_snap_list_exit, + TP_ARGS( + int, retval, + rados_snap_t*, snaps, + int, num_snaps), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_sequence(rados_snap_t, snaps, snaps, uint32_t, num_snaps) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_snap_lookup_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, name), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(name, name) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_snap_lookup_exit, + TP_ARGS( + int, retval, + uint64_t, snapid), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(uint64_t, snapid, snapid) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_snap_get_name_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + uint64_t, snapid, + int, maxlen), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_integer(uint64_t, snapid, snapid) + ctf_integer(int, maxlen, maxlen) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_snap_get_name_exit, + TP_ARGS( + int, retval, + const char*, name), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_string(name, name) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_snap_get_stamp_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + uint64_t, snapid), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_integer(uint64_t, snapid, snapid) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_snap_get_stamp_exit, + TP_ARGS( + int, retval, + time_t, time), + TP_FIELDS( + ctf_integer(int, retval, retval) + ceph_ctf_time_t(time, time) + ) +) + +TRACEPOINT_EVENT(librados, rados_cmpext_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + const char*, cmp_buf, + size_t, cmp_len, + uint64_t, off), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ceph_ctf_sequence(unsigned char, cmp_buf, cmp_buf, size_t, cmp_len) + ctf_integer(uint64_t, off, off) + ) +) + +TRACEPOINT_EVENT(librados, rados_cmpext_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_getxattr_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + const char*, aname, + size_t, len), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_string(aname, aname) + ctf_integer(size_t, len, len) + ) +) + +TRACEPOINT_EVENT(librados, rados_getxattr_exit, + TP_ARGS( + int, retval, + const char*, value, + int, len), + TP_FIELDS( + ctf_integer(int, retval, retval) + ceph_ctf_sequence(unsigned char, value, value, uint64_t, len) + ) +) + +TRACEPOINT_EVENT(librados, rados_getxattrs_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ) +) + +TRACEPOINT_EVENT(librados, rados_getxattrs_exit, + TP_ARGS( + int, retval, + rados_xattrs_iter_t, iter), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer_hex(rados_xattrs_iter_t, iter, iter) + ) +) + +TRACEPOINT_EVENT(librados, rados_getxattrs_next_enter, + TP_ARGS( + rados_xattrs_iter_t, iter), + TP_FIELDS( + ctf_integer_hex(rados_xattrs_iter_t, iter, iter) + ) +) + +TRACEPOINT_EVENT(librados, rados_getxattrs_next_exit, + TP_ARGS( + int, retval, + const char*, aname, + const char*, value, + size_t, len), + TP_FIELDS( + ctf_integer(int, retval, retval) + ceph_ctf_string(aname, aname) + ceph_ctf_sequence(unsigned char, value, value, size_t, len) + ) +) + +TRACEPOINT_EVENT(librados, rados_getxattrs_end_enter, + TP_ARGS( + rados_xattrs_iter_t, iter), + TP_FIELDS( + ctf_integer_hex(rados_xattrs_iter_t, iter, iter) + ) +) + +TRACEPOINT_EVENT(librados, rados_getxattrs_end_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_setxattr_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + const char*, aname, + const char*, value, + size_t, len), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_string(aname, aname) + ceph_ctf_sequence(unsigned char, value, value, size_t, len) + ) +) + +TRACEPOINT_EVENT(librados, rados_setxattr_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_rmxattr_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + const char*, aname), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_string(aname, aname) + ) +) + +TRACEPOINT_EVENT(librados, rados_rmxattr_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_stat_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ) +) + +TRACEPOINT_EVENT(librados, rados_stat_exit, + TP_ARGS( + int, retval, + uint64_t*, size, + time_t*, mtime), + TP_FIELDS( + ctf_integer(int, retval, retval) + ceph_ctf_integerp(uint64_t, size, size) + ceph_ctf_time_tp(mtime, mtime) + ) +) + +TRACEPOINT_EVENT(librados, rados_stat2_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ) +) + +TRACEPOINT_EVENT(librados, rados_stat2_exit, + TP_ARGS( + int, retval, + uint64_t*, size, + struct timespec*, mtime), + TP_FIELDS( + ctf_integer(int, retval, retval) + ceph_ctf_integerp(uint64_t, size, size) + ceph_ctf_timespecp(mtime, mtime) + ) +) + +TRACEPOINT_EVENT(librados, rados_exec_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + const char*, cls, + const char*, method, + const char*, inbuf, + size_t, in_len, + size_t, out_len), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_string(cls, cls) + ctf_string(method, method) + ceph_ctf_sequence(unsigned char, inbuf, inbuf, size_t, in_len) + ctf_integer(size_t, out_len, out_len) + ) +) + +TRACEPOINT_EVENT(librados, rados_exec_exit, + TP_ARGS( + int, retval, + char*, outbuf, + size_t, len), + TP_FIELDS( + ctf_integer(int, retval, retval) + ceph_ctf_sequence(unsigned char, outbuf, outbuf, size_t, len) + ) +) + +TRACEPOINT_EVENT(librados, rados_nobjects_list_open_enter, + TP_ARGS( + rados_ioctx_t, ioctx), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_nobjects_list_open_exit, + TP_ARGS( + int, retval, + rados_list_ctx_t, listctx), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer_hex(rados_list_ctx_t, listctx, listctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_nobjects_list_close_enter, + TP_ARGS( + rados_list_ctx_t, listctx), + TP_FIELDS( + ctf_integer_hex(rados_list_ctx_t, listctx, listctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_nobjects_list_close_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_nobjects_list_seek_enter, + TP_ARGS( + rados_list_ctx_t, listctx, + uint32_t, pos), + TP_FIELDS( + ctf_integer_hex(rados_list_ctx_t, listctx, listctx) + ctf_integer(uint32_t, pos, pos) + ) +) + +TRACEPOINT_EVENT(librados, rados_nobjects_list_seek_exit, + TP_ARGS( + uint32_t, retval), + TP_FIELDS( + ctf_integer(uint32_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_nobjects_list_seek_cursor_enter, + TP_ARGS( + rados_list_ctx_t, listctx), + TP_FIELDS( + ctf_integer_hex(rados_list_ctx_t, listctx, listctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_nobjects_list_seek_cursor_exit, + TP_ARGS( + uint32_t, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_nobjects_list_get_cursor_enter, + TP_ARGS( + rados_list_ctx_t, listctx), + TP_FIELDS( + ctf_integer_hex(rados_list_ctx_t, listctx, listctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_nobjects_list_get_cursor_exit, + TP_ARGS( + uint32_t, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_nobjects_list_get_pg_hash_position_enter, + TP_ARGS( + rados_list_ctx_t, listctx), + TP_FIELDS( + ctf_integer_hex(rados_list_ctx_t, listctx, listctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_nobjects_list_get_pg_hash_position_exit, + TP_ARGS( + uint32_t, retval), + TP_FIELDS( + ctf_integer(uint32_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_nobjects_list_next_enter, + TP_ARGS( + rados_list_ctx_t, listctx), + TP_FIELDS( + ctf_integer_hex(rados_list_ctx_t, listctx, listctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_nobjects_list_next_exit, + TP_ARGS( + int, retval, + const char*, entry, + char const* const*, key, + char const* const*, nspace), + TP_FIELDS( + ctf_integer(int, retval, retval) + ceph_ctf_string(entry, entry) + ceph_ctf_stringp(key, key) + ceph_ctf_stringp(nspace, nspace) + ) +) + +TRACEPOINT_EVENT(librados, rados_nobjects_list_next2_enter, + TP_ARGS( + rados_list_ctx_t, listctx), + TP_FIELDS( + ctf_integer_hex(rados_list_ctx_t, listctx, listctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_nobjects_list_next2_exit, + TP_ARGS( + int, retval, + const char* const*, entry, + const char* const*, key, + const char* const*, nspace, + const size_t*, entry_size, + const size_t*, key_size, + const size_t*, nspace_size), + TP_FIELDS( + ctf_integer(int, retval, retval) + ceph_ctf_sequencep(char, entry, entry, size_t, entry_size) + ceph_ctf_sequencep(char, key, key, size_t, key_size) + ceph_ctf_sequencep(char, nspace, nspace, size_t, nspace_size) + ) +) + + +TRACEPOINT_EVENT(librados, rados_objects_list_open_enter, + TP_ARGS( + rados_ioctx_t, ioctx), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_objects_list_open_exit, + TP_ARGS( + int, retval, + rados_list_ctx_t, listctx), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer_hex(rados_list_ctx_t, listctx, listctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_objects_list_close_enter, + TP_ARGS( + rados_list_ctx_t, listctx), + TP_FIELDS( + ctf_integer_hex(rados_list_ctx_t, listctx, listctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_objects_list_close_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_objects_list_seek_enter, + TP_ARGS( + rados_list_ctx_t, listctx, + uint32_t, pos), + TP_FIELDS( + ctf_integer_hex(rados_list_ctx_t, listctx, listctx) + ctf_integer(uint32_t, pos, pos) + ) +) + +TRACEPOINT_EVENT(librados, rados_objects_list_seek_exit, + TP_ARGS( + uint32_t, retval), + TP_FIELDS( + ctf_integer(uint32_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_objects_list_get_pg_hash_position_enter, + TP_ARGS( + rados_list_ctx_t, listctx), + TP_FIELDS( + ctf_integer_hex(rados_list_ctx_t, listctx, listctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_objects_list_get_pg_hash_position_exit, + TP_ARGS( + uint32_t, retval), + TP_FIELDS( + ctf_integer(uint32_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_objects_list_next_enter, + TP_ARGS( + rados_list_ctx_t, listctx), + TP_FIELDS( + ctf_integer_hex(rados_list_ctx_t, listctx, listctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_objects_list_next_exit, + TP_ARGS( + int, retval, + const char*, entry, + char const* const*, key), + TP_FIELDS( + ctf_integer(int, retval, retval) + ceph_ctf_string(entry, entry) + ceph_ctf_stringp(key, key) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_create_completion_enter, + TP_ARGS( + void*, cb_arg, + rados_callback_t, cb_complete, + rados_callback_t, cb_safe), + TP_FIELDS( + ctf_integer_hex(void*, cb_arg, cb_arg) + ctf_integer_hex(rados_callback_t, cb_complete, cb_complete) + ctf_integer_hex(rados_callback_t, cb_safe, cb_safe) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_create_completion_exit, + TP_ARGS( + int, retval, + rados_completion_t, completion), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_create_completion2_enter, + TP_ARGS( + void*, cb_arg, + rados_callback_t, cb_complete), + TP_FIELDS( + ctf_integer_hex(void*, cb_arg, cb_arg) + ctf_integer_hex(rados_callback_t, cb_complete, cb_complete) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_create_completion2_exit, + TP_ARGS( + int, retval, + rados_completion_t, completion), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_wait_for_complete_enter, + TP_ARGS( + rados_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_wait_for_complete_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_wait_for_safe_enter, + TP_ARGS( + rados_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_wait_for_safe_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_is_complete_enter, + TP_ARGS( + rados_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_is_complete_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_is_safe_enter, + TP_ARGS( + rados_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_is_safe_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_wait_for_complete_and_cb_enter, + TP_ARGS( + rados_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_wait_for_complete_and_cb_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_wait_for_safe_and_cb_enter, + TP_ARGS( + rados_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_wait_for_safe_and_cb_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_is_complete_and_cb_enter, + TP_ARGS( + rados_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_is_complete_and_cb_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_is_safe_and_cb_enter, + TP_ARGS( + rados_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_is_safe_and_cb_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_get_return_value_enter, + TP_ARGS( + rados_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_get_return_value_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_get_version_enter, + TP_ARGS( + rados_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_get_version_exit, + TP_ARGS( + uint64_t, retval), + TP_FIELDS( + ctf_integer(uint64_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_release_enter, + TP_ARGS( + rados_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_release_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_aio_read_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + rados_completion_t, completion, + size_t, len, + uint64_t, off), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer_hex(rados_completion_t, completion, completion) + ctf_integer(size_t, len, len) + ctf_integer(uint64_t, off, off) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_read_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_write_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + rados_completion_t, completion, + const char*, buf, + size_t, len, + uint64_t, off), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer_hex(rados_completion_t, completion, completion) + ctf_sequence(unsigned char, buf, buf, size_t, CEPH_MIN(len, CEPH_TRACE_BUF_TRUNC_LEN)) + ctf_integer(size_t, len, len) + ctf_integer(uint64_t, off, off) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_write_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_append_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + rados_completion_t, completion, + const char*, buf, + size_t, len), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer_hex(rados_completion_t, completion, completion) + ctf_sequence(unsigned char, buf, buf, size_t, CEPH_MIN(len, CEPH_TRACE_BUF_TRUNC_LEN)) + ctf_integer(size_t, len, len) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_append_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_write_full_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + rados_completion_t, completion, + const char*, buf, + size_t, len), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer_hex(rados_completion_t, completion, completion) + ctf_sequence(unsigned char, buf, buf, size_t, CEPH_MIN(len, CEPH_TRACE_BUF_TRUNC_LEN)) + ctf_integer(size_t, len, len) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_write_full_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_writesame_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + rados_completion_t, completion, + const char*, buf, + size_t, data_len, + size_t, write_len, + uint64_t, off), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer_hex(rados_completion_t, completion, completion) + ctf_sequence(unsigned char, buf, buf, size_t, CEPH_MIN(data_len, CEPH_TRACE_BUF_TRUNC_LEN)) + ctf_integer(size_t, data_len, data_len) + ctf_integer(size_t, write_len, write_len) + ctf_integer(uint64_t, off, off) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_writesame_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + + +TRACEPOINT_EVENT(librados, rados_aio_remove_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + rados_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_remove_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_flush_async_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + rados_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_flush_async_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_flush_enter, + TP_ARGS( + rados_ioctx_t, ioctx), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_flush_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_getxattr_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + rados_completion_t, completion, + const char*, aname, + size_t, len), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer_hex(rados_completion_t, completion, completion) + ctf_string(aname, aname) + ctf_integer(size_t, len, len) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_getxattr_exit, + TP_ARGS( + int, retval, + const char*, value, + int, len), + TP_FIELDS( + ctf_integer(int, retval, retval) + ceph_ctf_sequence(unsigned char, value, value, uint64_t, len) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_getxattrs_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + rados_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_getxattrs_exit, + TP_ARGS( + int, retval, + rados_xattrs_iter_t, iter), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer_hex(rados_xattrs_iter_t, iter, iter) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_setxattr_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + rados_completion_t, completion, + const char*, aname, + const char*, value, + size_t, len), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer_hex(rados_completion_t, completion, completion) + ctf_string(aname, aname) + ceph_ctf_sequence(unsigned char, value, value, size_t, len) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_setxattr_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_rmxattr_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + rados_completion_t, completion, + const char*, aname), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer_hex(rados_completion_t, completion, completion) + ctf_string(aname, aname) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_rmxattr_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_stat_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + rados_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_stat_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_stat2_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + rados_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_stat2_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_exec_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + rados_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_exec_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_cmpext_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + rados_completion_t, completion, + const char*, cmp_buf, + size_t, cmp_len, + uint64_t, off), + TP_FIELDS( + ceph_ctf_sequence(unsigned char, cmp_buf, cmp_buf, size_t, cmp_len) + ctf_integer(uint64_t, off, off) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_cmpext_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_watch_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + uint64_t, version, + rados_watchcb_t, callback, + void*, arg), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer(uint64_t, version, version) + ctf_integer_hex(rados_watchcb_t, callback, callback) + ctf_integer_hex(void*, arg, arg) + ) +) + +TRACEPOINT_EVENT(librados, rados_watch_exit, + TP_ARGS( + int, retval, + uint64_t, handle), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(uint64_t, handle, handle) + ) +) + +TRACEPOINT_EVENT(librados, rados_watch3_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + uint64_t*, phandle, + rados_watchcb2_t, callback, + uint32_t, timeout, + void*, arg), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer_hex(uint64_t, phandle, phandle) + ctf_integer_hex(rados_watchcb2_t, callback, callback) + ctf_integer(uint32_t, timeout, timeout) + ctf_integer_hex(void*, arg, arg) + ) +) + +TRACEPOINT_EVENT(librados, rados_watch3_exit, + TP_ARGS( + int, retval, + uint64_t, handle), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(uint64_t, handle, handle) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_watch2_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + rados_completion_t, completion, + uint64_t*, phandle, + rados_watchcb2_t, callback, + uint32_t, timeout, + void*, arg), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer_hex(rados_completion_t, completion, completion) + ctf_integer_hex(uint64_t, phandle, phandle) + ctf_integer_hex(rados_watchcb2_t, callback, callback) + ctf_integer(uint32_t, timeout, timeout) + ctf_integer_hex(void*, arg, arg) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_watch2_exit, + TP_ARGS( + int, retval, + uint64_t, handle), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(uint64_t, handle, handle) + ) +) + +TRACEPOINT_EVENT(librados, rados_unwatch_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + uint64_t, handle), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer(uint64_t, handle, handle) + ) +) + +TRACEPOINT_EVENT(librados, rados_unwatch_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_unwatch2_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + uint64_t, handle), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_integer(uint64_t, handle, handle) + ) +) + +TRACEPOINT_EVENT(librados, rados_unwatch2_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_unwatch_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + uint64_t, handle, + rados_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_integer(uint64_t, handle, handle) + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_unwatch_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_watch_check_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + uint64_t, handle), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_integer(uint64_t, handle, handle) + ) +) + +TRACEPOINT_EVENT(librados, rados_watch_check_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_notify_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + uint64_t, version, + const char*, buf, + int, buf_len), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer(uint64_t, version, version) + ceph_ctf_sequence(unsigned char, buf, buf, size_t, buf_len) + ) +) + +TRACEPOINT_EVENT(librados, rados_notify_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_notify2_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + const char*, buf, + int, buf_len, + uint64_t, timeout_ms), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ceph_ctf_sequence(unsigned char, buf, buf, size_t, buf_len) + ctf_integer(uint64_t, timeout_ms, timeout_ms) + ) +) + +TRACEPOINT_EVENT(librados, rados_notify2_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_notify_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + rados_completion_t, completion, + const char*, buf, + int, buf_len, + uint64_t, timeout_ms), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer_hex(rados_completion_t, completion, completion) + ceph_ctf_sequence(unsigned char, buf, buf, size_t, buf_len) + ctf_integer(uint64_t, timeout_ms, timeout_ms) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_notify_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_notify_ack_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + uint64_t, notify_id, + uint64_t, handle, + const char*, buf, + int, buf_len), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer(uint64_t, notify_id, notify_id) + ctf_integer(uint64_t, handle, handle) + ceph_ctf_sequence(unsigned char, buf, buf, size_t, buf_len) + ) +) + +TRACEPOINT_EVENT(librados, rados_notify_ack_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_watch_flush_enter, + TP_ARGS( + rados_t, cluster), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ) +) + +TRACEPOINT_EVENT(librados, rados_watch_flush_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_watch_flush_enter, + TP_ARGS( + rados_t, cluster, + rados_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_watch_flush_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_set_alloc_hint_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + uint64_t, expected_object_size, + uint64_t, expected_write_size), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer(uint64_t, expected_object_size, expected_object_size) + ctf_integer(uint64_t, expected_write_size, expected_write_size) + ) +) + +TRACEPOINT_EVENT(librados, rados_set_alloc_hint_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_set_alloc_hint2_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + uint64_t, expected_object_size, + uint64_t, expected_write_size, + uint32_t, flags), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer(uint64_t, expected_object_size, expected_object_size) + ctf_integer(uint64_t, expected_write_size, expected_write_size) + ctf_integer(uint32_t, flags, flags) + ) +) + +TRACEPOINT_EVENT(librados, rados_set_alloc_hint2_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_lock_exclusive_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + const char*, name, + const char*, cookie, + const char*, description, + struct timeval*, duration, + uint8_t, flags), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ceph_ctf_string(name, name) + ceph_ctf_string(cookie, cookie) + ceph_ctf_string(description, description) + ceph_ctf_timevalp(duration, duration) + ctf_integer(uint8_t, flags, flags) + ) +) + +TRACEPOINT_EVENT(librados, rados_lock_exclusive_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_lock_shared_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + const char*, name, + const char*, cookie, + const char*, tag, + const char*, description, + struct timeval*, duration, + uint8_t, flags), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ceph_ctf_string(name, name) + ceph_ctf_string(cookie, cookie) + ceph_ctf_string(tag, tag) + ceph_ctf_string(description, description) + ceph_ctf_timevalp(duration, duration) + ctf_integer(uint8_t, flags, flags) + ) +) + +TRACEPOINT_EVENT(librados, rados_lock_shared_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_unlock_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + const char*, name, + const char*, cookie), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ceph_ctf_string(name, name) + ceph_ctf_string(cookie, cookie) + ) +) + +TRACEPOINT_EVENT(librados, rados_unlock_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_unlock_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + const char*, name, + const char*, cookie, + rados_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ceph_ctf_string(name, name) + ceph_ctf_string(cookie, cookie) + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_unlock_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_list_lockers_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + const char*, name, + size_t, tag_len, + size_t, clients_len, + size_t, cookies_len, + size_t, addrs_len), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ceph_ctf_string(name, name) + ctf_integer(size_t, tag_len, tag_len) + ctf_integer(size_t, clients_len, clients_len) + ctf_integer(size_t, cookies_len, cookies_len) + ctf_integer(size_t, addrs_len, addrs_len) + ) +) + +TRACEPOINT_EVENT(librados, rados_list_lockers_locker, + TP_ARGS( + const char*, client, + const char*, cookie, + const char*, addr), + TP_FIELDS( + ctf_string(client, client) + ctf_string(cookie, cookie) + ctf_string(addr, addr) + ) +) + +TRACEPOINT_EVENT(librados, rados_list_lockers_exit, + TP_ARGS( + int, retval, + int, exclusive, + const char*, tag, + size_t, tag_len, + size_t, clients_len, + size_t, cookies_len, + size_t, addrs_len), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(int, exclusive, exclusive) + ctf_string(tag, tag) + ctf_integer(size_t, tag_len, tag_len) + ctf_integer(size_t, clients_len, clients_len) + ctf_integer(size_t, cookies_len, cookies_len) + ctf_integer(size_t, addrs_len, addrs_len) + ) +) + +TRACEPOINT_EVENT(librados, rados_break_lock_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + const char*, name, + const char*, client, + const char*, cookie), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ceph_ctf_string(name, name) + ceph_ctf_string(client, client) + ceph_ctf_string(cookie, cookie) + ) +) + +TRACEPOINT_EVENT(librados, rados_break_lock_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_create_write_op_enter, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_create_write_op_exit, + TP_ARGS( + rados_write_op_t, retval), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_release_write_op_enter, + TP_ARGS( + rados_write_op_t, op), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ) +) + +TRACEPOINT_EVENT(librados, rados_release_write_op_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_set_flags_enter, + TP_ARGS( + rados_write_op_t, op, + int, flags), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ctf_integer(int, flags, flags) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_set_flags_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_assert_version_enter, + TP_ARGS( + rados_write_op_t, op, + uint64_t, ver), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ctf_integer(uint64_t, ver, ver) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_assert_version_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_assert_exists_enter, + TP_ARGS( + rados_write_op_t, op), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_assert_exists_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_cmpext_enter, + TP_ARGS( + rados_write_op_t, op, + const char*, cmp_buffer, + size_t, cmp_len, + uint64_t, offset, + int*, prval), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ceph_ctf_sequence(unsigned char, cmp_buffer, cmp_buffer, size_t, cmp_len) + ctf_integer(size_t, cmp_len, cmp_len) + ctf_integer(uint64_t, offset, offset) + ctf_integer_hex(void*, prval, prval) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_cmpext_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_cmpxattr_enter, + TP_ARGS( + rados_write_op_t, op, + const char*, aname, + uint8_t, comparison_operator, + const char*, value, + size_t, value_len), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ceph_ctf_string(aname, aname) + ctf_integer(uint8_t, comparison_operator, comparison_operator) + ceph_ctf_sequence(unsigned char, value, value, size_t, value_len) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_cmpxattr_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_omap_cmp_enter, + TP_ARGS( + rados_write_op_t, op, + const char*, name, + uint8_t, comparison_operator, + const char*, value, + size_t, value_len, + int*, prval), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ceph_ctf_string(name, name) + ctf_integer(uint8_t, comparison_operator, comparison_operator) + ceph_ctf_sequence(unsigned char, value, value, size_t, value_len) + ctf_integer_hex(int*, prval, prval) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_omap_cmp_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_setxattr_enter, + TP_ARGS( + rados_write_op_t, op, + const char*, name, + const char*, value, + size_t, value_len), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ceph_ctf_string(name, name) + ceph_ctf_sequence(unsigned char, value, value, size_t, value_len) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_setxattr_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_rmxattr_enter, + TP_ARGS( + rados_write_op_t, op, + const char*, name), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ceph_ctf_string(name, name) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_rmxattr_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_create_enter, + TP_ARGS( + rados_write_op_t, op, + int, exclusive), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ctf_integer(int, exclusive, exclusive) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_create_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_write_enter, + TP_ARGS( + rados_write_op_t, op, + const char*, buffer, + size_t, len, + uint64_t, offset), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ceph_ctf_sequence(unsigned char, buffer, buffer, size_t, len) + ctf_integer(uint64_t, offset, offset) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_write_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_write_full_enter, + TP_ARGS( + rados_write_op_t, op, + const char*, buffer, + size_t, len), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ceph_ctf_sequence(unsigned char, buffer, buffer, size_t, len) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_write_full_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_writesame_enter, + TP_ARGS( + rados_write_op_t, op, + const char*, buffer, + size_t, data_len, + size_t, write_len, + uint64_t, offset), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ceph_ctf_sequence(unsigned char, buffer, buffer, size_t, data_len) + ctf_integer(size_t, write_len, write_len) + ctf_integer(uint64_t, offset, offset) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_writesame_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_append_enter, + TP_ARGS( + rados_write_op_t, op, + const char*, buffer, + size_t, len), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ceph_ctf_sequence(unsigned char, buffer, buffer, size_t, len) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_append_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_remove_enter, + TP_ARGS( + rados_write_op_t, op), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_remove_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_truncate_enter, + TP_ARGS( + rados_write_op_t, op, + uint64_t, offset), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ctf_integer(uint64_t, offset, offset) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_truncate_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_zero_enter, + TP_ARGS( + rados_write_op_t, op, + uint64_t, offset, + uint64_t, len), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ctf_integer(uint64_t, offset, offset) + ctf_integer(uint64_t, len, len) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_zero_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_exec_enter, + TP_ARGS( + rados_write_op_t, op, + const char*, cls, + const char*, method, + const char*, in_buf, + size_t, in_len, + int*, prval), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ceph_ctf_string(cls, cls) + ceph_ctf_string(method, method) + ceph_ctf_sequence(unsigned char, in_buf, in_buf, size_t, in_len) + ctf_integer_hex(int*, prval, prval) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_exec_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_omap_set_enter, + TP_ARGS( + rados_write_op_t, op, + size_t, num), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ctf_integer(size_t, num, num) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_omap_set_entry, + TP_ARGS( + const char*, key, + const char*, value, + size_t, value_len), + TP_FIELDS( + ceph_ctf_string(key, key) + ceph_ctf_sequence(unsigned char, value, value, size_t, value_len) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_omap_set_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_omap_rm_keys_enter, + TP_ARGS( + rados_write_op_t, op, + size_t, num), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ctf_integer(size_t, num, num) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_omap_rm_keys_entry, + TP_ARGS( + const char*, key), + TP_FIELDS( + ceph_ctf_string(key, key) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_omap_rm_keys_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_omap_rm_range_enter, + TP_ARGS( + rados_write_op_t, op, + const char*, key_begin, + const char*, key_end), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ceph_ctf_string(key_begin, key_begin) + ceph_ctf_string(key_end, key_end) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_omap_rm_range_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_omap_clear_enter, + TP_ARGS( + rados_write_op_t, op), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_omap_clear_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_set_alloc_hint_enter, + TP_ARGS( + rados_write_op_t, op, + uint64_t, expected_object_size, + uint64_t, expected_write_size), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ctf_integer(uint64_t, expected_object_size, expected_object_size) + ctf_integer(uint64_t, expected_write_size, expected_write_size) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_set_alloc_hint_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_set_alloc_hint2_enter, + TP_ARGS( + rados_write_op_t, op, + uint64_t, expected_object_size, + uint64_t, expected_write_size, + uint32_t, flags), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ctf_integer(uint64_t, expected_object_size, expected_object_size) + ctf_integer(uint64_t, expected_write_size, expected_write_size) + ctf_integer(uint32_t, flags, flags) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_set_alloc_hint2_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_operate_enter, + TP_ARGS( + rados_write_op_t, op, + rados_ioctx_t, ioctx, + const char*, oid, + time_t*, mtime, + int, flags), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ceph_ctf_time_tp(mtime, mtime) + ctf_integer_hex(int, flags, flags) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_operate2_enter, + TP_ARGS( + rados_write_op_t, op, + rados_ioctx_t, ioctx, + const char*, oid, + struct timespec*, ts, + int, flags), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ceph_ctf_timespecp(ts, ts) + ctf_integer_hex(int, flags, flags) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_operate_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_write_op_operate_enter, + TP_ARGS( + rados_write_op_t, op, + rados_ioctx_t, ioctx, + rados_completion_t, completion, + const char*, oid, + time_t*, mtime, + int, flags), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_integer_hex(rados_completion_t, completion, completion) + ctf_string(oid, oid) + ceph_ctf_time_tp(mtime, mtime) + ctf_integer_hex(int, flags, flags) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_write_op_operate2_enter, + TP_ARGS( + rados_write_op_t, op, + rados_ioctx_t, ioctx, + rados_completion_t, completion, + const char*, oid, + struct timespec*, ts, + int, flags), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_integer_hex(rados_completion_t, completion, completion) + ctf_string(oid, oid) + ceph_ctf_timespecp(ts, ts) + ctf_integer_hex(int, flags, flags) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_write_op_operate_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_create_read_op_enter, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_create_read_op_exit, + TP_ARGS( + rados_read_op_t, retval), + TP_FIELDS( + ctf_integer_hex(rados_read_op_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_release_read_op_enter, + TP_ARGS( + rados_read_op_t, read_op), + TP_FIELDS( + ctf_integer_hex(rados_read_op_t, read_op, read_op) + ) +) + +TRACEPOINT_EVENT(librados, rados_release_read_op_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_read_op_set_flags_enter, + TP_ARGS( + rados_read_op_t, read_op, + int, flags), + TP_FIELDS( + ctf_integer_hex(rados_read_op_t, read_op, read_op) + ctf_integer_hex(int, flags, flags) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_op_set_flags_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_read_op_assert_version_enter, + TP_ARGS( + rados_read_op_t, read_op, + uint64_t, ver), + TP_FIELDS( + ctf_integer_hex(rados_read_op_t, read_op, read_op) + ctf_integer(uint64_t, ver, ver) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_op_assert_version_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_read_op_assert_exists_enter, + TP_ARGS( + rados_read_op_t, read_op), + TP_FIELDS( + ctf_integer_hex(rados_read_op_t, read_op, read_op) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_op_assert_exists_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_read_op_cmpext_enter, + TP_ARGS( + rados_read_op_t, op, + const char*, cmp_buffer, + size_t, cmp_len, + uint64_t, offset, + int*, prval), + TP_FIELDS( + ctf_integer_hex(rados_read_op_t, op, op) + ceph_ctf_sequence(unsigned char, cmp_buffer, cmp_buffer, size_t, cmp_len) + ctf_integer(size_t, cmp_len, cmp_len) + ctf_integer(uint64_t, offset, offset) + ctf_integer_hex(void*, prval, prval) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_op_cmpext_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_read_op_cmpxattr_enter, + TP_ARGS( + rados_read_op_t, read_op, + const char*, name, + uint8_t, comparison_operator, + const char*, value, + size_t, value_len), + TP_FIELDS( + ctf_integer_hex(rados_read_op_t, read_op, read_op) + ctf_string(name, name) + ctf_integer(uint8_t, comparison_operator, comparison_operator) + ceph_ctf_sequence(unsigned char, value, value, size_t, value_len) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_op_cmpxattr_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_read_op_omap_cmp_enter, + TP_ARGS( + rados_read_op_t, read_op, + const char*, name, + uint8_t, comparison_operator, + const char*, value, + size_t, value_len, + void*, prval), + TP_FIELDS( + ctf_integer_hex(rados_read_op_t, read_op, read_op) + ctf_string(name, name) + ctf_integer(uint8_t, comparison_operator, comparison_operator) + ceph_ctf_sequence(unsigned char, value, value, size_t, value_len) + ctf_integer_hex(void*, prval, prval) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_op_omap_cmp_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_read_op_stat_enter, + TP_ARGS( + rados_read_op_t, read_op, + void*, psize, + void*, pmtime, + void*, prval), + TP_FIELDS( + ctf_integer_hex(rados_read_op_t, read_op, read_op) + ctf_integer_hex(void*, psize, psize) + ctf_integer_hex(void*, pmtime, pmtime) + ctf_integer_hex(void*, prval, prval) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_op_stat_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_read_op_stat2_enter, + TP_ARGS( + rados_read_op_t, read_op, + void*, psize, + void*, pmtime, + void*, prval), + TP_FIELDS( + ctf_integer_hex(rados_read_op_t, read_op, read_op) + ctf_integer_hex(void*, psize, psize) + ctf_integer_hex(void*, pmtime, pmtime) + ctf_integer_hex(void*, prval, prval) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_op_stat2_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_read_op_read_enter, + TP_ARGS( + rados_read_op_t, read_op, + uint64_t, offset, + size_t, len, + char*, buf, + size_t*, bytes_read, + int*, prval), + TP_FIELDS( + ctf_integer_hex(rados_read_op_t, read_op, read_op) + ctf_integer(uint64_t, offset, offset) + ctf_integer(size_t, len, len) + ctf_integer_hex(void*, buf, buf) + ctf_integer_hex(void*, bytes_read, bytes_read) + ctf_integer_hex(void*, prval, prval) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_op_read_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_read_op_checksum_enter, + TP_ARGS( + rados_read_op_t, read_op, + int, type, + const char*, init_value, + size_t, init_value_len, + uint64_t, offset, + size_t, len, + size_t, chunk_size), + TP_FIELDS( + ctf_integer_hex(rados_read_op_t, read_op, read_op) + ctf_integer(int, type, type) + ceph_ctf_sequence(unsigned char, init_value, init_value, size_t, init_value_len) + ctf_integer(uint64_t, offset, offset) + ctf_integer(size_t, len, len) + ctf_integer(size_t, chunk_size, chunk_size) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_op_checksum_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_read_op_exec_enter, + TP_ARGS( + rados_read_op_t, read_op, + const char*, cls, + const char*, method, + const char*, in_buf, + size_t, in_len, + char**, out_buf, + size_t*, out_len, + int*, prval), + TP_FIELDS( + ctf_integer_hex(rados_read_op_t, read_op, read_op) + ceph_ctf_string(cls, cls) + ceph_ctf_string(method, method) + ceph_ctf_sequence(unsigned char, in_buf, in_buf, size_t, in_len) + ctf_integer_hex(void*, out_buf, out_buf) + ctf_integer_hex(void*, out_len, out_len) + ctf_integer_hex(void*, prval, prval) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_op_exec_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_read_op_exec_user_buf_enter, + TP_ARGS( + rados_read_op_t, read_op, + const char*, cls, + const char*, method, + const char*, in_buf, + size_t, in_len, + char*, out_buf, + size_t, out_len, + size_t*, used_len, + int*, prval), + TP_FIELDS( + ctf_integer_hex(rados_read_op_t, read_op, read_op) + ceph_ctf_string(cls, cls) + ceph_ctf_string(method, method) + ceph_ctf_sequence(unsigned char, in_buf, in_buf, size_t, in_len) + ctf_integer_hex(void*, out_buf, out_buf) + ctf_integer(size_t, out_len, out_len) + ctf_integer_hex(void*, used_len, used_len) + ctf_integer_hex(void*, prval, prval) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_op_exec_user_buf_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_read_op_getxattrs_enter, + TP_ARGS( + rados_read_op_t, read_op, + int*, prval), + TP_FIELDS( + ctf_integer_hex(rados_read_op_t, read_op, read_op) + ctf_integer_hex(void*, prval, prval) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_op_getxattrs_exit, + TP_ARGS( + rados_xattrs_iter_t, iter), + TP_FIELDS( + ctf_integer_hex(rados_xattrs_iter_t, iter, iter) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_op_omap_get_vals_enter, + TP_ARGS( + rados_read_op_t, read_op, + const char*, start_after, + const char*, filter_prefix, + uint64_t, max_return, + int*, prval), + TP_FIELDS( + ctf_integer_hex(rados_read_op_t, read_op, read_op) + ceph_ctf_string(start_after, start_after) + ceph_ctf_string(filter_prefix, filter_prefix) + ctf_integer(uint64_t, max_return, max_return) + ctf_integer_hex(void*, prval, prval) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_op_omap_get_vals_exit, + TP_ARGS( + rados_omap_iter_t, iter), + TP_FIELDS( + ctf_integer_hex(rados_omap_iter_t, iter, iter) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_op_omap_get_keys_enter, + TP_ARGS( + rados_read_op_t, read_op, + const char*, start_after, + uint64_t, max_return, + int*, prval), + TP_FIELDS( + ctf_integer_hex(rados_read_op_t, read_op, read_op) + ceph_ctf_string(start_after, start_after) + ctf_integer(uint64_t, max_return, max_return) + ctf_integer_hex(void*, prval, prval) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_op_omap_get_keys_exit, + TP_ARGS( + rados_omap_iter_t, iter), + TP_FIELDS( + ctf_integer_hex(rados_omap_iter_t, iter, iter) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_op_omap_get_vals_by_keys_enter, + TP_ARGS( + rados_read_op_t, read_op, + char const* const*, keys, + size_t, keys_len, + rados_omap_iter_t*, piter, + int*, prval), + TP_FIELDS( + ctf_integer_hex(rados_read_op_t, read_op, read_op) + ctf_integer_hex(void*, keys, keys) + ctf_integer(size_t, keys_len, keys_len) + ctf_integer_hex(void*, piter, piter) + ctf_integer_hex(void*, prval, prval) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_op_omap_get_vals_by_keys_exit, + TP_ARGS( + rados_omap_iter_t, iter), + TP_FIELDS( + ctf_integer_hex(rados_omap_iter_t, iter, iter) + ) +) + +TRACEPOINT_EVENT(librados, rados_omap_get_next_enter, + TP_ARGS( + rados_omap_iter_t, iter), + TP_FIELDS( + ctf_integer_hex(rados_omap_iter_t, iter, iter) + ) +) + +TRACEPOINT_EVENT(librados, rados_omap_get_next_exit, + TP_ARGS( + int, retval, + char**, key, + char**, val, + size_t*, len), + TP_FIELDS( + ctf_integer(int, retval, retval) + ceph_ctf_stringp(key, key) + ceph_ctf_sequencep(unsigned char, val, val, size_t, len) + ) +) + +TRACEPOINT_EVENT(librados, rados_omap_get_end_enter, + TP_ARGS( + rados_omap_iter_t, iter), + TP_FIELDS( + ctf_integer_hex(rados_omap_iter_t, iter, iter) + ) +) + +TRACEPOINT_EVENT(librados, rados_omap_get_end_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_read_op_operate_enter, + TP_ARGS( + rados_read_op_t, read_op, + rados_ioctx_t, ctx, + const char*, oid, + int, flags), + TP_FIELDS( + ctf_integer_hex(rados_read_op_t, read_op, read_op) + ctf_integer_hex(rados_ioctx_t, ctx, ctx) + ctf_string(oid, oid) + ctf_integer(int, flags, flags) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_op_operate_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_read_op_operate_enter, + TP_ARGS( + rados_read_op_t, read_op, + rados_ioctx_t, ctx, + rados_completion_t, completion, + const char*, oid, + int, flags), + TP_FIELDS( + ctf_integer_hex(rados_read_op_t, read_op, read_op) + ctf_integer_hex(rados_ioctx_t, ctx, ctx) + ctf_integer_hex(rados_completion_t, completion, completion) + ceph_ctf_string(oid, oid) + ctf_integer(int, flags, flags) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_read_op_operate_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_cache_pin_enter, + TP_ARGS( + rados_ioctx_t, io, + const char*, o), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, io, io) + ceph_ctf_string(o, o) + ) +) + +TRACEPOINT_EVENT(librados, rados_cache_pin_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_cache_unpin_enter, + TP_ARGS( + rados_ioctx_t, io, + const char*, o), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, io, io) + ceph_ctf_string(o, o) + ) +) + +TRACEPOINT_EVENT(librados, rados_cache_unpin_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_inconsistent_pg_list_enter, + TP_ARGS( + rados_t, cluster, + int64_t, id, + size_t, maxlen), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_integer(int64_t, id, id) + ctf_integer(size_t, maxlen, maxlen) + ) +) + +TRACEPOINT_EVENT(librados, rados_inconsistent_pg_list_pg, + TP_ARGS( + const char*, buf), + TP_FIELDS( + ctf_string(buf, buf) + ) +) + +TRACEPOINT_EVENT(librados, rados_inconsistent_pg_list_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) diff --git a/src/tracing/librbd.c b/src/tracing/librbd.c new file mode 100644 index 000000000..c70bf8ef9 --- /dev/null +++ b/src/tracing/librbd.c @@ -0,0 +1,6 @@ + +#define TRACEPOINT_CREATE_PROBES +/* + * The header containing our TRACEPOINT_EVENTs. + */ +#include "tracing/librbd.h" diff --git a/src/tracing/librbd.tp b/src/tracing/librbd.tp new file mode 100644 index 000000000..b2624d5b1 --- /dev/null +++ b/src/tracing/librbd.tp @@ -0,0 +1,2932 @@ +#include "tracing/tracing-common.h" +#include "include/rbd/librbd.h" +#include "include/int_types.h" + +TRACEPOINT_EVENT(librbd, read_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only, + uint64_t, offset, + uint64_t, length), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ctf_integer(uint64_t, offset, offset) + ctf_integer(uint64_t, length, length) + ) +) + +TRACEPOINT_EVENT(librbd, read2_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only, + uint64_t, offset, + uint64_t, length, + int, op_flags), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ctf_integer(uint64_t, offset, offset) + ctf_integer(uint64_t, length, length) + ctf_integer(int, op_flags, op_flags) + ) +) +TRACEPOINT_EVENT(librbd, read_exit, + TP_ARGS( + ssize_t, retval), + TP_FIELDS( + ctf_integer(ssize_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, read_iterate_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only, + uint64_t, offset, + uint64_t, length), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ctf_integer(uint64_t, offset, offset) + ctf_integer(uint64_t, length, length) + ) +) + +TRACEPOINT_EVENT(librbd, read_iterate_exit, + TP_ARGS( + int64_t, retval), + TP_FIELDS( + ctf_integer(int64_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, read_iterate2_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only, + uint64_t, offset, + uint64_t, length), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ctf_integer(uint64_t, offset, offset) + ctf_integer(uint64_t, length, length) + ) +) + +TRACEPOINT_EVENT(librbd, read_iterate2_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, write_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only, + uint64_t, off, + size_t, len, + const char*, buf), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ctf_integer(uint64_t, off, off) + ceph_ctf_sequence(unsigned char, buf, buf, size_t, len) + ) +) + +TRACEPOINT_EVENT(librbd, write2_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only, + uint64_t, off, + size_t, len, + const char*, buf, + int, op_flags), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ctf_integer(uint64_t, off, off) + ceph_ctf_sequence(unsigned char, buf, buf, size_t, len) + ctf_integer(int, op_flags, op_flags) + ) +) + + +TRACEPOINT_EVENT(librbd, write_exit, + TP_ARGS( + ssize_t, retval), + TP_FIELDS( + ctf_integer(ssize_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, open_image_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, id, + const char*, snap_name, + int, read_only), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(id, id) + ctf_string(snap_name, snap_name) + ctf_integer(uint8_t, read_only, read_only ? 1 : 0) + ) +) + +TRACEPOINT_EVENT(librbd, open_image_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, writesame_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only, + uint64_t, off, + size_t, len, + const char*, buf, + size_t, data_len, + int, op_flags), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ctf_integer(uint64_t, off, off) + ctf_integer(size_t, len, len) + ctf_integer(size_t, data_len, data_len) + ceph_ctf_sequence(unsigned char, buf, buf, size_t, data_len) + ctf_integer(int, op_flags, op_flags) + ) +) + +TRACEPOINT_EVENT(librbd, writesame_exit, + TP_ARGS( + ssize_t, retval), + TP_FIELDS( + ctf_integer(ssize_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, compare_and_write_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only, + uint64_t, off, + size_t, len, + const char*, cmp_buf, + const char*, buf, + int, op_flags), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ctf_integer(uint64_t, off, off) + ceph_ctf_sequence(unsigned char, cmp_buf, cmp_buf, size_t, len) + ceph_ctf_sequence(unsigned char, buf, buf, size_t, len) + ctf_integer(int, op_flags, op_flags) + ) +) + +TRACEPOINT_EVENT(librbd, compare_and_write_exit, + TP_ARGS( + ssize_t, retval), + TP_FIELDS( + ctf_integer(ssize_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, open_image_by_id_enter, + TP_ARGS( + void*, imagectx, + const char*, id, + const char*, snap_name, + int, read_only), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(id, id) + ctf_string(snap_name, snap_name) + ctf_integer(uint8_t, read_only, read_only ? 1 : 0) + ) +) + +TRACEPOINT_EVENT(librbd, open_image_by_id_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, aio_open_image_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, id, + const char*, snap_name, + int, read_only, + const void*, completion), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(id, id) + ctf_string(snap_name, snap_name) + ctf_integer(uint8_t, read_only, read_only ? 1 : 0) + ctf_integer_hex(const void*, completion, completion) + ) +) + +TRACEPOINT_EVENT(librbd, aio_open_image_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, aio_open_image_by_id_enter, + TP_ARGS( + void*, imagectx, + const char*, id, + const char*, snap_name, + int, read_only, + const void*, completion), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(id, id) + ctf_string(snap_name, snap_name) + ctf_integer(uint8_t, read_only, read_only ? 1 : 0) + ctf_integer_hex(const void*, completion, completion) + ) +) + +TRACEPOINT_EVENT(librbd, aio_open_image_by_id_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, close_image_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, id), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(id, id) + ) +) + +TRACEPOINT_EVENT(librbd, close_image_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval)) +) + +TRACEPOINT_EVENT(librbd, aio_close_image_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, id, + const void*, completion), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(id, id) + ctf_integer_hex(const void*, completion, completion) + ) +) + +TRACEPOINT_EVENT(librbd, aio_close_image_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval)) +) + +TRACEPOINT_EVENT(librbd, list_enter, + TP_ARGS( + const char*, pool_name, + int64_t, id), + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(int64_t, id, id) + ) +) + +TRACEPOINT_EVENT(librbd, list_entry, + TP_ARGS( + const char*, name), + TP_FIELDS( + ctf_string(name, name) + ) +) + +TRACEPOINT_EVENT(librbd, list_exit, + TP_ARGS( + int, retval, + int, size), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(size_t, size, size) + ) +) + +TRACEPOINT_EVENT(librbd, create_enter, + TP_ARGS( + const char*, pool_name, + int64_t, id, + const char*, imgname, + uint64_t, size, + int, order), + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(int64_t, id, id) + ctf_string(imgname, imgname) + ctf_integer(uint64_t, size, size) + ctf_integer(int, order, order) + ) +) + +TRACEPOINT_EVENT(librbd, create_exit, + TP_ARGS( + int, retval, + int, order), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(int, order, order) + ) +) + +TRACEPOINT_EVENT(librbd, create2_enter, + TP_ARGS( + const char*, pool_name, + int64_t, id, + const char*, imgname, + uint64_t, size, + uint64_t, features, + int, order), + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(int64_t, id, id) + ctf_string(imgname, imgname) + ctf_integer(uint64_t, size, size) + ctf_integer(uint64_t, features, features) + ctf_integer(int, order, order) + ) +) + +TRACEPOINT_EVENT(librbd, create2_exit, + TP_ARGS( + int, retval, + int, order), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(int, order, order) + ) +) + +TRACEPOINT_EVENT(librbd, create3_enter, + TP_ARGS( + const char*, pool_name, + int64_t, id, + const char*, imgname, + uint64_t, size, + uint64_t, features, + int, order, + uint64_t, stripe_unit, + uint64_t, stripe_count), + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(int64_t, id, id) + ctf_string(imgname, imgname) + ctf_integer(uint64_t, size, size) + ctf_integer(uint64_t, features, features) + ctf_integer(int, order, order) + ctf_integer(uint64_t, stripe_unit, stripe_unit) + ctf_integer(uint64_t, stripe_count, stripe_count) + ) +) + +TRACEPOINT_EVENT(librbd, create3_exit, + TP_ARGS( + int, retval, + int, order), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(int, order, order) + ) +) + +TRACEPOINT_EVENT(librbd, create4_enter, + TP_ARGS( + const char*, pool_name, + int64_t, id, + const char*, imgname, + uint64_t, size, + void*, opts), + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(int64_t, id, id) + ctf_string(imgname, imgname) + ctf_integer_hex(void*, opts, opts) + ) +) + +TRACEPOINT_EVENT(librbd, create4_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, remove_enter, + TP_ARGS( + const char*, pool_name, + int64_t, id, + const char*, imgname), + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(int64_t, id, id) + ctf_string(imgname, imgname) + ) +) + +TRACEPOINT_EVENT(librbd, remove_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, trash_move_enter, + TP_ARGS( + const char*, pool_name, + int64_t, id, + const char*, imgname), + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(int64_t, id, id) + ctf_string(imgname, imgname) + ) +) + +TRACEPOINT_EVENT(librbd, trash_move_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, trash_list_enter, + TP_ARGS( + const char*, pool_name, + int64_t, id), + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(int64_t, id, id) + ) +) + +TRACEPOINT_EVENT(librbd, trash_list_entry, + TP_ARGS( + const char*, id), + TP_FIELDS( + ctf_string(id, id) + ) +) + +TRACEPOINT_EVENT(librbd, trash_list_exit, + TP_ARGS( + int, retval, + int, size), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(size_t, size, size) + ) +) + +TRACEPOINT_EVENT(librbd, trash_purge_enter, + TP_ARGS( + const char*, pool_name, + int64_t, id, + time_t, expire_ts, + float, threshold), + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(int64_t, id, id) + ceph_ctf_time_t(expire_ts, expire_ts) + ctf_float(float, threshold, threshold) + ) +) + +TRACEPOINT_EVENT(librbd, trash_purge_exit, + TP_ARGS(int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, trash_remove_enter, + TP_ARGS( + const char*, pool_name, + int64_t, id, + const char*, imgid, + uint8_t, force), + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(int64_t, id, id) + ctf_string(imgid, imgid) + ctf_integer(uint8_t, force, force) + ) +) + +TRACEPOINT_EVENT(librbd, trash_remove_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, trash_undelete_enter, + TP_ARGS( + const char*, pool_name, + int64_t, id, + const char*, imgid, + const char*, imgnewname), + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(int64_t, id, id) + ctf_string(imgid, imgid) + ctf_string(imgnewname, imgnewname) + ) +) + +TRACEPOINT_EVENT(librbd, trash_undelete_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, aio_write_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only, + uint64_t, off, + size_t, len, + const char*, buf, + const void*, completion), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ctf_integer(uint64_t, off, off) + ctf_integer(size_t, len, len) + ceph_ctf_sequence(unsigned char, buf, buf, size_t, len) + ctf_integer_hex(const void*, completion, completion) + ) +) + +TRACEPOINT_EVENT(librbd, aio_write2_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only, + uint64_t, off, + size_t, len, + const char*, buf, + const void*, completion, + int, op_flags), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ctf_integer(uint64_t, off, off) + ctf_integer(size_t, len, len) + ceph_ctf_sequence(unsigned char, buf, buf, size_t, len) + ctf_integer_hex(const void*, completion, completion) + ctf_integer(int, op_flags, op_flags) + ) +) +TRACEPOINT_EVENT(librbd, aio_write_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, aio_read_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only, + uint64_t, offset, + uint64_t, length, + const char*, buf, + const void*, completion), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ctf_integer(uint64_t, offset, offset) + ctf_integer(uint64_t, length, length) + ctf_integer_hex(const void*, completion, completion) + ) +) + +TRACEPOINT_EVENT(librbd, aio_read2_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only, + uint64_t, offset, + uint64_t, length, + const char*, buf, + const void*, completion, + int, op_flags), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ctf_integer(uint64_t, offset, offset) + ctf_integer(uint64_t, length, length) + ctf_integer_hex(const void*, completion, completion) + ctf_integer(int, op_flags, op_flags) + ) +) + + +TRACEPOINT_EVENT(librbd, aio_read_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, aio_discard_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only, + uint64_t, off, + uint64_t, len, + void*, completion), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ctf_integer(uint64_t, off, off) + ctf_integer(uint64_t, len, len) + ctf_integer_hex(void*, completion, completion) + ) +) + +TRACEPOINT_EVENT(librbd, aio_discard_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, invalidate_cache_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ) +) + +TRACEPOINT_EVENT(librbd, invalidate_cache_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, poll_io_events_enter, + TP_ARGS( + void*, imagectx, + int, numcomp), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_integer(int, numcomp, numcomp) + ) +) + +TRACEPOINT_EVENT(librbd, poll_io_events_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) +TRACEPOINT_EVENT(librbd, metadata_get_enter, + TP_ARGS( + void*, imagectx, + const char*, key), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(key, key) + ) +) + +TRACEPOINT_EVENT(librbd, metadata_get_exit, + TP_ARGS( + int, retval, + const char*, key, + const char*, value), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_string(key, key) + ctf_string(value, value) + ) +) + +TRACEPOINT_EVENT(librbd, metadata_set_enter, + TP_ARGS( + void*, imagectx, + const char*, key, + const char*, value), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(key, key) + ctf_string(value, value) + ) +) + +TRACEPOINT_EVENT(librbd, metadata_set_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, metadata_remove_enter, + TP_ARGS( + void*, imagectx, + const char*, key), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(key, key) + ) +) + +TRACEPOINT_EVENT(librbd, metadata_remove_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, metadata_list_enter, + TP_ARGS( + void*, imagectx), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ) +) + +TRACEPOINT_EVENT(librbd, metadata_list_entry, + TP_ARGS( + const char*, key, + const char*, value), + TP_FIELDS( + ctf_string(key, key) + ctf_string(value, value) + ) +) + +TRACEPOINT_EVENT(librbd, metadata_list_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, flush_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ) +) + +TRACEPOINT_EVENT(librbd, flush_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, aio_flush_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only, + const void*, completion), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ctf_integer_hex(const void*, completion, completion) + ) +) + +TRACEPOINT_EVENT(librbd, aio_flush_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, copy_enter, + TP_ARGS( + void*, src_imagectx, + const char*, src_name, + const char*, src_snap_name, + char, src_read_only, + const char*, dst_pool_name, + uint64_t, dst_id, + const char*, dst_name), + TP_FIELDS( + ctf_integer_hex(void*, src_imagectx, src_imagectx) + ctf_string(src_name, src_name) + ctf_string(src_snap_name, src_snap_name) + ctf_integer(char, src_read_only, src_read_only) + ctf_string(dst_pool_name, dst_pool_name) + ctf_integer(uint64_t, dst_id, dst_id) + ctf_string(dst_name, dst_name) + ) +) + +TRACEPOINT_EVENT(librbd, copy_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, copy2_enter, + TP_ARGS( + void*, src_imagectx, + const char*, src_name, + const char*, src_snap_name, + char, src_read_only, + void*, dst_imagectx, + const char*, dst_name, + const char*, dst_snap_name, + char, dst_read_only), + TP_FIELDS( + ctf_integer_hex(void*, src_imagectx, src_imagectx) + ctf_string(src_name, src_name) + ctf_string(src_snap_name, src_snap_name) + ctf_integer(char, src_read_only, src_read_only) + ctf_integer_hex(void*, dst_imagectx, dst_imagectx) + ctf_string(dst_name, dst_name) + ctf_string(dst_snap_name, dst_snap_name) + ctf_integer(char, dst_read_only, dst_read_only) + ) +) + +TRACEPOINT_EVENT(librbd, copy2_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, copy3_enter, + TP_ARGS( + void*, src_imagectx, + const char*, src_name, + const char*, src_snap_name, + char, src_read_only, + const char*, dst_pool_name, + uint64_t, dst_id, + const char*, dst_name, + void*, opts), + TP_FIELDS( + ctf_integer_hex(void*, src_imagectx, src_imagectx) + ctf_string(src_name, src_name) + ctf_string(src_snap_name, src_snap_name) + ctf_integer(char, src_read_only, src_read_only) + ctf_string(dst_pool_name, dst_pool_name) + ctf_integer(uint64_t, dst_id, dst_id) + ctf_string(dst_name, dst_name) + ctf_integer_hex(void*, opts, opts) + ) +) + +TRACEPOINT_EVENT(librbd, copy3_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, copy4_enter, + TP_ARGS( + void*, src_imagectx, + const char*, src_name, + const char*, src_snap_name, + char, src_read_only, + const char*, dst_pool_name, + uint64_t, dst_id, + const char*, dst_name, + void*, opts, + size_t, sparse_size), + TP_FIELDS( + ctf_integer_hex(void*, src_imagectx, src_imagectx) + ctf_string(src_name, src_name) + ctf_string(src_snap_name, src_snap_name) + ctf_integer(char, src_read_only, src_read_only) + ctf_string(dst_pool_name, dst_pool_name) + ctf_integer(uint64_t, dst_id, dst_id) + ctf_string(dst_name, dst_name) + ctf_integer_hex(void*, opts, opts) + ctf_integer(size_t, sparse_size, sparse_size) + ) +) + +TRACEPOINT_EVENT(librbd, copy4_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, deep_copy_enter, + TP_ARGS( + void*, src_imagectx, + const char*, src_name, + const char*, src_snap_name, + char, src_read_only, + const char*, dst_pool_name, + uint64_t, dst_id, + const char*, dst_name, + void*, opts), + TP_FIELDS( + ctf_integer_hex(void*, src_imagectx, src_imagectx) + ctf_string(src_name, src_name) + ctf_string(src_snap_name, src_snap_name) + ctf_integer(char, src_read_only, src_read_only) + ctf_string(dst_pool_name, dst_pool_name) + ctf_integer(uint64_t, dst_id, dst_id) + ctf_string(dst_name, dst_name) + ctf_integer_hex(void*, opts, opts) + ) +) + +TRACEPOINT_EVENT(librbd, deep_copy_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, resize_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only, + uint64_t, size), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ctf_integer(uint64_t, size, size) + ) +) + +TRACEPOINT_EVENT(librbd, resize_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, rename_enter, + TP_ARGS( + const char*, pool_name, + uint64_t, id, + const char*, srcname, + const char*, dstname), + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(uint64_t, id, id) + ctf_string(srcname, srcname) + ctf_string(dstname, dstname) + ) +) + +TRACEPOINT_EVENT(librbd, rename_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, migration_prepare_enter, + TP_ARGS( + const char*, pool_name, + uint64_t, id, + const char*, image_name, + const char*, dest_pool_name, + uint64_t, dest_id, + const char*, dest_image_name, + void*, opts), + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(uint64_t, id, id) + ctf_string(image_name, image_name) + ctf_string(dest_pool_name, dest_pool_name) + ctf_integer(uint64_t, dest_id, dest_id) + ctf_string(dest_image_name, dest_image_name) + ctf_integer_hex(void*, opts, opts) + ) +) + +TRACEPOINT_EVENT(librbd, migration_prepare_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, migration_execute_enter, + TP_ARGS( + const char*, pool_name, + int64_t, pool_id, + const char*, image_name), + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(int64_t, pool_id, pool_id) + ctf_string(image_name, image_name) + ) +) + +TRACEPOINT_EVENT(librbd, migration_execute_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, migration_abort_enter, + TP_ARGS( + const char*, pool_name, + int64_t, pool_id, + const char*, image_name), + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(int64_t, pool_id, pool_id) + ctf_string(image_name, image_name) + ) +) + +TRACEPOINT_EVENT(librbd, migration_abort_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, migration_commit_enter, + TP_ARGS( + const char*, pool_name, + int64_t, pool_id, + const char*, image_name), + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(int64_t, pool_id, pool_id) + ctf_string(image_name, image_name) + ) +) + +TRACEPOINT_EVENT(librbd, migration_commit_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, migration_status_enter, + TP_ARGS( + const char*, pool_name, + int64_t, pool_id, + const char*, image_name), + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(int64_t, pool_id, pool_id) + ctf_string(image_name, image_name) + ) +) + +TRACEPOINT_EVENT(librbd, migration_status_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, discard_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only, + uint64_t, off, + uint64_t, len), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ctf_integer(uint64_t, off, off) + ctf_integer(uint64_t, len, len) + ) +) + +TRACEPOINT_EVENT(librbd, discard_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, aio_is_complete_enter, + TP_ARGS( + rbd_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rbd_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librbd, aio_is_complete_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, aio_get_return_value_enter, + TP_ARGS( + rbd_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rbd_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librbd, aio_get_return_value_exit, + TP_ARGS( + ssize_t, retval), + TP_FIELDS( + ctf_integer(ssize_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, aio_wait_for_complete_enter, + TP_ARGS( + rbd_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rbd_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librbd, aio_wait_for_complete_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, aio_complete_enter, + TP_ARGS( + rbd_completion_t, completion, + ssize_t, rval), + TP_FIELDS( + ctf_integer_hex(rbd_completion_t, completion, completion) + ctf_integer(ssize_t, rval, rval) + ) +) + +TRACEPOINT_EVENT(librbd, aio_complete_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librbd, aio_writesame_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only, + uint64_t, off, + size_t, len, + const char*, buf, + size_t, data_len, + const void*, completion, + int, op_flags), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ctf_integer(uint64_t, off, off) + ctf_integer(size_t, len, len) + ctf_integer(size_t, data_len, data_len) + ceph_ctf_sequence(unsigned char, buf, buf, size_t, data_len) + ctf_integer_hex(const void*, completion, completion) + ctf_integer(int, op_flags, op_flags) + ) +) + +TRACEPOINT_EVENT(librbd, aio_writesame_exit, + TP_ARGS( + ssize_t, retval), + TP_FIELDS( + ctf_integer(ssize_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, aio_compare_and_write_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only, + uint64_t, off, + size_t, len, + const char*, cmp_buf, + const char*, buf, + const void*, completion, + int, op_flags), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ctf_integer(uint64_t, off, off) + ctf_integer(size_t, len, len) + ceph_ctf_sequence(unsigned char, cmp_buf, cmp_buf, size_t, len) + ceph_ctf_sequence(unsigned char, buf, buf, size_t, len) + ctf_integer_hex(const void*, completion, completion) + ctf_integer(int, op_flags, op_flags) + ) +) +TRACEPOINT_EVENT(librbd, aio_compare_and_write_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + + +TRACEPOINT_EVENT(librbd, clone_enter, + TP_ARGS( + const char*, parent_pool_name, + uint64_t, parent_id, + const char*, parent_name, + const char*, parent_snap_name, + const char*, child_pool_name, + uint64_t, child_id, + const char*, child_name, + uint64_t, features), + TP_FIELDS( + ctf_string(parent_pool_name, parent_pool_name) + ctf_integer(uint64_t, parent_id, parent_id) + ctf_string(parent_name, parent_name) + ctf_string(parent_snap_name, parent_snap_name) + ctf_string(child_pool_name, child_pool_name) + ctf_integer(uint64_t, child_id, child_id) + ctf_string(child_name, child_name) + ctf_integer(uint64_t, features, features) + ) +) + +TRACEPOINT_EVENT(librbd, clone_exit, + TP_ARGS( + int, retval, + int, order), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(int, order, order) + ) +) + +TRACEPOINT_EVENT(librbd, clone2_enter, + TP_ARGS( + const char*, parent_pool_name, + uint64_t, parent_id, + const char*, parent_name, + const char*, parent_snap_name, + const char*, child_pool_name, + uint64_t, child_id, + const char*, child_name, + uint64_t, features, + uint64_t, stripe_unit, + int, stripe_count), + TP_FIELDS( + ctf_string(parent_pool_name, parent_pool_name) + ctf_integer(uint64_t, parent_id, parent_id) + ctf_string(parent_name, parent_name) + ctf_string(parent_snap_name, parent_snap_name) + ctf_string(child_pool_name, child_pool_name) + ctf_integer(uint64_t, child_id, child_id) + ctf_string(child_name, child_name) + ctf_integer(uint64_t, features, features) + ctf_integer(uint64_t, stripe_unit, stripe_unit) + ctf_integer(int, stripe_count, stripe_count) + ) +) + +TRACEPOINT_EVENT(librbd, clone2_exit, + TP_ARGS( + int, retval, + int, order), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(int, order, order) + ) +) + +TRACEPOINT_EVENT(librbd, clone3_enter, + TP_ARGS( + const char*, parent_pool_name, + uint64_t, parent_id, + const char*, parent_name, + const char*, parent_snap_name, + const char*, child_pool_name, + uint64_t, child_id, + const char*, child_name, + void*, opts), + TP_FIELDS( + ctf_string(parent_pool_name, parent_pool_name) + ctf_integer(uint64_t, parent_id, parent_id) + ctf_string(parent_name, parent_name) + ctf_string(parent_snap_name, parent_snap_name) + ctf_string(child_pool_name, child_pool_name) + ctf_integer(uint64_t, child_id, child_id) + ctf_string(child_name, child_name) + ctf_integer_hex(void*, opts, opts) + ) +) + +TRACEPOINT_EVENT(librbd, clone3_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, flatten_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, id), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(id, id) + ) +) + +TRACEPOINT_EVENT(librbd, flatten_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, sparsify_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + size_t, sparse_size, + const char*, id), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_integer(size_t, sparse_size, sparse_size) + ctf_string(id, id) + ) +) + +TRACEPOINT_EVENT(librbd, sparsify_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, snap_create_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only, + const char*, create_snap_name), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ctf_string(create_snap_name, create_snap_name) + ) +) + +TRACEPOINT_EVENT(librbd, snap_create_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, snap_remove_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only, + const char*, remove_snap_name), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ctf_string(remove_snap_name, remove_snap_name) + ) +) + +TRACEPOINT_EVENT(librbd, snap_remove_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, snap_remove2_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only, + const char*, remove_snap_name, + uint32_t, flags), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ctf_string(remove_snap_name, remove_snap_name) + ctf_integer(uint32_t, flags, flags) + ) +) + +TRACEPOINT_EVENT(librbd, snap_remove2_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, snap_rollback_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only, + const char*, rollback_snap_name), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ctf_string(rollback_snap_name, rollback_snap_name) + ) +) + +TRACEPOINT_EVENT(librbd, snap_rollback_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, snap_rename_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only, + const char*, src_snap_name, + const char*, dst_snap_name), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ctf_string(src_snap_name, src_snap_name) + ctf_string(dst_snap_name, dst_snap_name) + ) +) + +TRACEPOINT_EVENT(librbd, snap_rename_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, snap_list_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only, + void*, snaps), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ctf_integer_hex(void*, snaps, snaps) + ) +) + +TRACEPOINT_EVENT(librbd, snap_list_entry, + TP_ARGS( + uint64_t, id, + uint64_t, size, + const char*, name), + TP_FIELDS( + ctf_integer(uint64_t, id, id) + ctf_integer(uint64_t, size, size) + ctf_string(name, name) + ) +) + +TRACEPOINT_EVENT(librbd, snap_list_exit, + TP_ARGS( + int, retval, + int, max_snaps), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(int, max_snaps, max_snaps) + ) +) + +TRACEPOINT_EVENT(librbd, snap_list_end_enter, + TP_ARGS( + void*, snaps), + TP_FIELDS( + ctf_integer_hex(void*, snaps, snaps) + ) +) + +TRACEPOINT_EVENT(librbd, snap_list_end_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librbd, snap_protect_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only, + const char*, protect_snap_name), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ctf_string(protect_snap_name, protect_snap_name) + ) +) + +TRACEPOINT_EVENT(librbd, snap_protect_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, snap_unprotect_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only, + const char*, unprotect_snap_name), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ctf_string(unprotect_snap_name, unprotect_snap_name) + ) +) + +TRACEPOINT_EVENT(librbd, snap_unprotect_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, snap_is_protected_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only, + const char*, is_protected_snap_name), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ctf_string(is_protected_snap_name, is_protected_snap_name) + ) +) + +TRACEPOINT_EVENT(librbd, snap_is_protected_exit, + TP_ARGS( + int, retval, + int, is_protected), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(int, is_protected, is_protected) + ) +) + +TRACEPOINT_EVENT(librbd, snap_exists_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only, + const char*, snap_name_to_check), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ctf_string(snap_name_to_check, snap_name_to_check) + ) +) + +TRACEPOINT_EVENT(librbd, snap_exists_exit, + TP_ARGS( + int, retval, + int, exists), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(int, exists, exists) + ) +) + +TRACEPOINT_EVENT(librbd, snap_get_timestamp_enter, + TP_ARGS( + void*, imagectx, + const char*, name), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ) +) + +TRACEPOINT_EVENT(librbd, snap_get_timestamp_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, snap_get_limit_enter, + TP_ARGS( + void*, imagectx, + const char*, name), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ) +) + +TRACEPOINT_EVENT(librbd, snap_get_limit_exit, + TP_ARGS( + int, retval, + uint64_t, limit), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(uint64_t, limit, limit) + ) +) + +TRACEPOINT_EVENT(librbd, snap_set_limit_enter, + TP_ARGS( + void*,imagectx, + const char*, name, + const int, limit), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_integer(int, limit, limit) + ) +) + +TRACEPOINT_EVENT(librbd, snap_set_limit_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, snap_set_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only, + const char*, set_snap_name), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ctf_string(set_snap_name, set_snap_name) + ) +) + +TRACEPOINT_EVENT(librbd, snap_set_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, list_children_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ) +) + +TRACEPOINT_EVENT(librbd, list_children_entry, + TP_ARGS( + const char*, pool, + const char*, image), + TP_FIELDS( + ctf_string(pool, pool) + ctf_string(image, image) + ) +) + +TRACEPOINT_EVENT(librbd, list_children_exit, + TP_ARGS( + ssize_t, retval), + TP_FIELDS( + ctf_integer(ssize_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, list_lockers_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ) +) + +TRACEPOINT_EVENT(librbd, list_lockers_entry, + TP_ARGS( + const char*, client, + const char*, cookie, + const char*, address), + TP_FIELDS( + ctf_string(client, client) + ctf_string(cookie, cookie) + ctf_string(address, address) + ) +) + +TRACEPOINT_EVENT(librbd, list_lockers_exit, + TP_ARGS( + ssize_t, retval), + TP_FIELDS( + ctf_integer(ssize_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, lock_exclusive_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only, + const char*, cookie), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ceph_ctf_string(cookie, cookie) + ) +) + +TRACEPOINT_EVENT(librbd, lock_exclusive_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, lock_shared_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only, + const char*, cookie, + const char*, tag), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ceph_ctf_string(cookie, cookie) + ceph_ctf_string(tag, tag) + ) +) + +TRACEPOINT_EVENT(librbd, lock_shared_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, unlock_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only, + const char*, cookie), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ceph_ctf_string(cookie, cookie) + ) +) + +TRACEPOINT_EVENT(librbd, unlock_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, break_lock_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only, + const char*, client, + const char*, cookie), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ceph_ctf_string(client, client) + ceph_ctf_string(cookie, cookie) + ) +) + +TRACEPOINT_EVENT(librbd, break_lock_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, diff_iterate_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only, + const char*, from_snap_name, + uint64_t, offset, + uint64_t, length, + char, include_parent, + char, whole_object), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ctf_string(from_snap_name, from_snap_name) + ctf_integer(uint64_t, offset, offset) + ctf_integer(uint64_t, length, length) + ctf_integer(char, include_parent, include_parent) + ctf_integer(char, whole_object, whole_object) + ) +) + +TRACEPOINT_EVENT(librbd, diff_iterate_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, get_parent_info_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ) +) + +TRACEPOINT_EVENT(librbd, get_parent_info_exit, + TP_ARGS( + int, retval, + const char*, parent_pool_name, + const char*, parent_name, + const char*, parent_id, + const char*, parent_snap_name), + TP_FIELDS( + ctf_integer(int, retval, retval) + ceph_ctf_string(parent_pool_name, parent_pool_name) + ceph_ctf_string(parent_name, parent_name) + ceph_ctf_string(parent_id, parent_id) + ceph_ctf_string(parent_snap_name, parent_snap_name) + ) +) + +TRACEPOINT_EVENT(librbd, get_overlap_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ) +) + +TRACEPOINT_EVENT(librbd, get_overlap_exit, + TP_ARGS( + int, retval, + uint64_t, overlap), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(uint64_t, overlap, overlap) + ) +) + +TRACEPOINT_EVENT(librbd, get_stripe_unit_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ) +) + +TRACEPOINT_EVENT(librbd, get_stripe_unit_exit, + TP_ARGS( + int, retval, + uint64_t, stripe_unit), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(uint64_t, stripe_unit, stripe_unit) + ) +) + +TRACEPOINT_EVENT(librbd, get_stripe_count_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ) +) + +TRACEPOINT_EVENT(librbd, get_stripe_count_exit, + TP_ARGS( + int, retval, + uint64_t, stripe_count), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(uint64_t, stripe_count, stripe_count) + ) +) + +TRACEPOINT_EVENT(librbd, get_create_timestamp_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + char, read_only), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_integer(char, read_only, read_only) + ) +) + +TRACEPOINT_EVENT(librbd, get_create_timestamp_exit, + TP_ARGS( + int, retval, + struct timespec*, timestamp), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(uint64_t, timestamp, timestamp->tv_sec) + ) +) + +TRACEPOINT_EVENT(librbd, get_access_timestamp_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + char, read_only), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_integer(char, read_only, read_only) + ) +) + +TRACEPOINT_EVENT(librbd, get_access_timestamp_exit, + TP_ARGS( + int, retval, + struct timespec*, timestamp), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(uint64_t, timestamp, timestamp->tv_sec) + ) +) + +TRACEPOINT_EVENT(librbd, get_modify_timestamp_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + char, read_only), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_integer(char, read_only, read_only) + ) +) + +TRACEPOINT_EVENT(librbd, get_modify_timestamp_exit, + TP_ARGS( + int, retval, + struct timespec*, timestamp), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(uint64_t, timestamp, timestamp->tv_sec) + ) +) + + +TRACEPOINT_EVENT(librbd, get_features_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ) +) + +TRACEPOINT_EVENT(librbd, get_features_exit, + TP_ARGS( + int, retval, + uint64_t, features), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(uint64_t, features, features) + ) +) + +TRACEPOINT_EVENT(librbd, update_features_enter, + TP_ARGS( + void*, imagectx, + uint64_t, features, + char, enabled), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_integer(uint64_t, features, features) + ctf_integer(char, enabled, enabled) + ) +) + +TRACEPOINT_EVENT(librbd, update_features_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, get_size_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ) +) + +TRACEPOINT_EVENT(librbd, get_size_exit, + TP_ARGS( + int, retval, + uint64_t, size), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(uint64_t, size, size) + ) +) + +TRACEPOINT_EVENT(librbd, get_old_format_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ) +) + +TRACEPOINT_EVENT(librbd, get_old_format_exit, + TP_ARGS( + int, retval, + uint64_t, old_format), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(uint64_t, old_format, old_format) + ) +) + +TRACEPOINT_EVENT(librbd, get_flags_enter, + TP_ARGS( + void*, imagectx), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ) +) + +TRACEPOINT_EVENT(librbd, get_flags_exit, + TP_ARGS( + void*, imagectx, + int, retval, + uint64_t, flags), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_integer(int, retval, retval) + ctf_integer(uint64_t, flags, flags) + ) +) + +TRACEPOINT_EVENT(librbd, set_image_notification_enter, + TP_ARGS( + void*, imagectx, + int, fd, + int, type), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_integer(int, fd, fd) + ctf_integer(int, type, type) + ) +) + +TRACEPOINT_EVENT(librbd, set_image_notification_exit, + TP_ARGS( + void*, imagectx, + int, retval), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, is_exclusive_lock_owner_enter, + TP_ARGS( + void*, imagectx), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ) +) + +TRACEPOINT_EVENT(librbd, is_exclusive_lock_owner_exit, + TP_ARGS( + void*, imagectx, + int, retval, + char, is_owner), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_integer(int, retval, retval) + ctf_integer(char, is_owner, is_owner) + ) +) + +TRACEPOINT_EVENT(librbd, lock_acquire_enter, + TP_ARGS( + void*, imagectx, + int, lock_mode), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_integer(int, lock_mode, lock_mode) + ) +) + +TRACEPOINT_EVENT(librbd, lock_acquire_exit, + TP_ARGS( + void*, imagectx, + int, retval), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, lock_release_enter, + TP_ARGS( + void*, imagectx), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ) +) + +TRACEPOINT_EVENT(librbd, lock_release_exit, + TP_ARGS( + void*, imagectx, + int, retval), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, lock_get_owners_enter, + TP_ARGS( + void*, imagectx), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ) +) + +TRACEPOINT_EVENT(librbd, lock_get_owners_exit, + TP_ARGS( + void*, imagectx, + int, retval), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, lock_break_enter, + TP_ARGS( + void*, imagectx, + int, lock_mode, + const char*, lock_owner), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_integer(int, lock_mode, lock_mode) + ctf_string(lock_owner, lock_owner) + ) +) + +TRACEPOINT_EVENT(librbd, lock_break_exit, + TP_ARGS( + void*, imagectx, + int, retval), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, stat_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ) +) + +TRACEPOINT_EVENT(librbd, stat_exit, + TP_ARGS( + int, retval, + rbd_image_info_t*, info), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(uint64_t, size, info->size) + ctf_integer(uint64_t, obj_size, info->obj_size) + ctf_integer(uint64_t, num_objs, info->num_objs) + ctf_integer(int, order, info->order) + ctf_array_text(char, block_name_prefix, info->block_name_prefix, RBD_MAX_BLOCK_NAME_SIZE) + ctf_integer(int64_t, parent_pool, info->parent_pool) + ctf_array_text(char, parent_name, info->parent_name, RBD_MAX_IMAGE_NAME_SIZE) + ) +) + +TRACEPOINT_EVENT(librbd, group_create_enter, + TP_ARGS( + const char*, pool_name, + int64_t, id, + const char*, groupname), + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(int64_t, id, id) + ctf_string(groupname, groupname) + ) +) + +TRACEPOINT_EVENT(librbd, group_create_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, group_remove_enter, + TP_ARGS( + const char*, pool_name, + int64_t, id, + const char*, groupname), + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(int64_t, id, id) + ctf_string(groupname, groupname) + ) +) + +TRACEPOINT_EVENT(librbd, group_remove_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, group_rename_enter, + TP_ARGS( + const char*, pool_name, + int64_t, id, + const char*, groupname, + const char*, destgroupname), + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(int64_t, id, id) + ctf_string(groupname, groupname) + ctf_string(destgroupname, destgroupname) + ) +) + +TRACEPOINT_EVENT(librbd, group_rename_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, group_list_enter, + TP_ARGS( + const char*, pool_name, + int64_t, id), + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(int64_t, id, id) + ) +) + +TRACEPOINT_EVENT(librbd, group_list_entry, + TP_ARGS( + const char*, name), + TP_FIELDS( + ctf_string(name, name) + ) +) + +TRACEPOINT_EVENT(librbd, group_list_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, update_watch_enter, + TP_ARGS( + void*, imagectx, + void*, watchctx), + TP_FIELDS( + ctf_integer_hex(void*, imagctx, imagectx) + ctf_integer_hex(void*, watchctx, watchctx) + ) +) + +TRACEPOINT_EVENT(librbd, update_watch_exit, + TP_ARGS( + int, retval, + uint64_t, handle), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(uint64_t, handle, handle) + ) +) + +TRACEPOINT_EVENT(librbd, update_unwatch_enter, + TP_ARGS( + void*, imagectx, + uint64_t, handle), + TP_FIELDS( + ctf_integer_hex(void*, imagctx, imagectx) + ctf_integer(uint64_t, handle, handle) + ) +) + +TRACEPOINT_EVENT(librbd, update_unwatch_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, snap_get_namespace_type_enter, + TP_ARGS( + void*, imagectx, + const char*, name), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ) +) + +TRACEPOINT_EVENT(librbd, snap_get_namespace_type_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, snap_get_group_namespace_enter, + TP_ARGS( + void*, imagectx, + const char*, name), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ) +) + +TRACEPOINT_EVENT(librbd, snap_get_group_namespace_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, group_image_add_enter, + TP_ARGS( + const char*, pool_name, + int64_t, id, + const char*, group_name, + const char*, image_pool_name, + int64_t, image_id, + const char*, image_name), + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(int64_t, id, id) + ctf_string(group_name, group_name) + ctf_string(image_pool_name, image_pool_name) + ctf_integer(int64_t, image_id, image_id) + ctf_string(image_name, image_name) + ) +) + +TRACEPOINT_EVENT(librbd, group_image_add_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, group_image_remove_enter, + TP_ARGS( + const char*, pool_name, + int64_t, id, + const char*, group_name, + const char*, image_pool_name, + int64_t, image_id, + const char*, image_name), + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(int64_t, id, id) + ctf_string(group_name, group_name) + ctf_string(image_pool_name, image_pool_name) + ctf_integer(int64_t, image_id, image_id) + ctf_string(image_name, image_name) + ) +) + +TRACEPOINT_EVENT(librbd, group_image_remove_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, group_image_remove_by_id_enter, + TP_ARGS( + const char*, pool_name, + int64_t, id, + const char*, group_name, + const char*, image_pool_name, + int64_t, image_ioctx_id, + const char*, image_id), + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(int64_t, id, id) + ctf_string(group_name, group_name) + ctf_string(image_pool_name, image_pool_name) + ctf_integer(int64_t, image_ioctx_id, image_ioctx_id) + ctf_string(image_id, image_id) + ) +) + +TRACEPOINT_EVENT(librbd, group_image_remove_by_id_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, group_image_list_enter, + TP_ARGS( + const char*, pool_name, + int64_t, id, + const char*, group_name), + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(int64_t, id, id) + ctf_string(group_name, group_name) + ) +) + +TRACEPOINT_EVENT(librbd, group_image_list_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, image_get_group_enter, + TP_ARGS( + const char*, image_name), + TP_FIELDS( + ctf_string(image_name, image_name) + ) +) + +TRACEPOINT_EVENT(librbd, image_get_group_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, group_snap_create_enter, + TP_ARGS( + const char*, pool_name, + int64_t, id, + const char*, group_name, + const char*, snap_name), + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(int64_t, id, id) + ctf_string(group_name, group_name) + ctf_string(snap_name, snap_name) + ) +) + +TRACEPOINT_EVENT(librbd, group_snap_create_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, group_snap_remove_enter, + TP_ARGS( + const char*, pool_name, + int64_t, id, + const char*, group_name, + const char*, snap_name), + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(int64_t, id, id) + ctf_string(group_name, group_name) + ctf_string(snap_name, snap_name) + ) +) + +TRACEPOINT_EVENT(librbd, group_snap_remove_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, group_snap_rename_enter, + TP_ARGS( + const char*, pool_name, + int64_t, id, + const char*, group_name, + const char*, old_snap_name, + const char*, new_snap_name), + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(int64_t, id, id) + ctf_string(group_name, group_name) + ctf_string(old_snap_name, old_snap_name) + ctf_string(new_snap_name, new_snap_name) + ) +) + +TRACEPOINT_EVENT(librbd, group_snap_rename_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, group_snap_list_enter, + TP_ARGS( + const char*, pool_name, + int64_t, id, + const char*, group_name), + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(int64_t, id, id) + ctf_string(group_name, group_name) + ) +) + +TRACEPOINT_EVENT(librbd, group_snap_list_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, group_snap_rollback_enter, + TP_ARGS( + const char*, pool_name, + int64_t, id, + const char*, group_name, + const char*, snap_name), + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(int64_t, id, id) + ctf_string(group_name, group_name) + ctf_string(snap_name, snap_name) + ) +) + +TRACEPOINT_EVENT(librbd, group_snap_rollback_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, list_watchers_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, snap_name, + char, read_only), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(snap_name, snap_name) + ctf_integer(char, read_only, read_only) + ) +) + +TRACEPOINT_EVENT(librbd, list_watchers_entry, + TP_ARGS( + const char*, addr, + int64_t, id, + uint64_t, cookie), + TP_FIELDS( + ctf_string(addr, addr) + ctf_integer(int64_t, id, id) + ctf_integer(uint64_t, cookie, cookie) + ) +) + +TRACEPOINT_EVENT(librbd, list_watchers_exit, + TP_ARGS( + int, retval, + size_t, num_watchers), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(size_t, num_watchers, num_watchers) + ) +) diff --git a/src/tracing/objectstore.c b/src/tracing/objectstore.c new file mode 100644 index 000000000..c1ec0eb13 --- /dev/null +++ b/src/tracing/objectstore.c @@ -0,0 +1,6 @@ + +#define TRACEPOINT_CREATE_PROBES +/* + * The header containing our TRACEPOINT_EVENTs. + */ +#include "tracing/objectstore.h" diff --git a/src/tracing/objectstore.tp b/src/tracing/objectstore.tp new file mode 100644 index 000000000..f5edd9ccf --- /dev/null +++ b/src/tracing/objectstore.tp @@ -0,0 +1,800 @@ +#include "include/int_types.h" + +TRACEPOINT_EVENT(objectstore, exists_enter, + TP_ARGS( + const char *, coll_name), + TP_FIELDS( + ctf_string(coll_name, coll_name) + ) +) + +TRACEPOINT_EVENT(objectstore, exists_exit, + TP_ARGS( + uint8_t, retval), + TP_FIELDS( + ctf_integer(uint8_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, stat_enter, + TP_ARGS( + const char *, coll_name), + TP_FIELDS( + ctf_string(coll_name, coll_name) + ) +) + +TRACEPOINT_EVENT(objectstore, stat_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, read_enter, + TP_ARGS( + const char *, coll_name, + uint64_t, offset, + size_t, len), + TP_FIELDS( + ctf_string(coll_name, coll_name) + ctf_integer(uint64_t, offset, offset) + ctf_integer(size_t, len, len) + ) +) + +TRACEPOINT_EVENT(objectstore, read_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, fiemap_enter, + TP_ARGS( + const char *, coll_name, + uint64_t, offset, + size_t, len), + TP_FIELDS( + ctf_string(coll_name, coll_name) + ctf_integer(uint64_t, offset, offset) + ctf_integer(size_t, len, len) + ) +) + +TRACEPOINT_EVENT(objectstore, fiemap_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, getattr_enter, + TP_ARGS( + const char *, coll_name), + TP_FIELDS( + ctf_string(coll_name, coll_name) + ) +) + +TRACEPOINT_EVENT(objectstore, getattr_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, getattrs_enter, + TP_ARGS( + const char *, coll_name), + TP_FIELDS( + ctf_string(coll_name, coll_name) + ) +) + +TRACEPOINT_EVENT(objectstore, getattrs_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, list_collections_enter, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(objectstore, list_collections_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, collection_stat_enter, + TP_ARGS( + const char *, coll_name), + TP_FIELDS( + ctf_string(coll_name, coll_name) + ) +) + +TRACEPOINT_EVENT(objectstore, collection_stat_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, collection_exists_enter, + TP_ARGS( + const char *, coll_name), + TP_FIELDS( + ctf_string(coll_name, coll_name) + ) +) + +TRACEPOINT_EVENT(objectstore, collection_exists_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, collection_empty_enter, + TP_ARGS( + const char *, coll_name), + TP_FIELDS( + ctf_string(coll_name, coll_name) + ) +) + +TRACEPOINT_EVENT(objectstore, collection_empty_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, collection_list_range_enter, + TP_ARGS( + const char *, coll_name), + TP_FIELDS( + ctf_string(coll_name, coll_name) + ) +) + +TRACEPOINT_EVENT(objectstore, collection_list_range_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, collection_list_partial_enter, + TP_ARGS( + const char *, coll_name), + TP_FIELDS( + ctf_string(coll_name, coll_name) + ) +) + +TRACEPOINT_EVENT(objectstore, collection_list_partial_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, collection_list_enter, + TP_ARGS( + const char *, coll_name), + TP_FIELDS( + ctf_string(coll_name, coll_name) + ) +) + +TRACEPOINT_EVENT(objectstore, collection_list_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, omap_get_enter, + TP_ARGS( + const char *, coll_name), + TP_FIELDS( + ctf_string(coll_name, coll_name) + ) +) + +TRACEPOINT_EVENT(objectstore, omap_get_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, omap_get_header_enter, + TP_ARGS( + const char *, coll_name), + TP_FIELDS( + ctf_string(coll_name, coll_name) + ) +) + +TRACEPOINT_EVENT(objectstore, omap_get_header_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, omap_get_keys_enter, + TP_ARGS( + const char *, coll_name), + TP_FIELDS( + ctf_string(coll_name, coll_name) + ) +) + +TRACEPOINT_EVENT(objectstore, omap_get_keys_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, omap_get_values_enter, + TP_ARGS( + const char *, coll_name), + TP_FIELDS( + ctf_string(coll_name, coll_name) + ) +) + +TRACEPOINT_EVENT(objectstore, omap_get_values_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, omap_check_keys_enter, + TP_ARGS( + const char *, coll_name), + TP_FIELDS( + ctf_string(coll_name, coll_name) + ) +) + +TRACEPOINT_EVENT(objectstore, omap_check_keys_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, get_omap_iterator, + TP_ARGS( + const char *, coll_name), + TP_FIELDS( + ctf_string(coll_name, coll_name) + ) +) + +TRACEPOINT_EVENT(objectstore, write_enter, + TP_ARGS( + const char *, osr_name, + uint64_t, offset, + uint64_t, length), + TP_FIELDS( + ctf_string(osr_name, osr_name) + ctf_integer(uint64_t, offset, offset) + ctf_integer(uint64_t, length, length) + ) +) + +TRACEPOINT_EVENT(objectstore, write_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, setallochint_enter, + TP_ARGS( + const char *, osr_name), + TP_FIELDS( + ctf_string(osr_name, osr_name) + ) +) + +TRACEPOINT_EVENT(objectstore, setallochint_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, split_coll_enter, + TP_ARGS( + const char *, osr_name), + TP_FIELDS( + ctf_string(osr_name, osr_name) + ) +) + +TRACEPOINT_EVENT(objectstore, split_coll_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, split_coll2_enter, + TP_ARGS( + const char *, osr_name), + TP_FIELDS( + ctf_string(osr_name, osr_name) + ) +) + +TRACEPOINT_EVENT(objectstore, split_coll2_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, merge_coll_enter, + TP_ARGS( + const char *, osr_name), + TP_FIELDS( + ctf_string(osr_name, osr_name) + ) +) + +TRACEPOINT_EVENT(objectstore, merge_coll_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, omap_setheader_enter, + TP_ARGS( + const char *, osr_name), + TP_FIELDS( + ctf_string(osr_name, osr_name) + ) +) + +TRACEPOINT_EVENT(objectstore, omap_setheader_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, omap_rmkeyrange_enter, + TP_ARGS( + const char *, osr_name), + TP_FIELDS( + ctf_string(osr_name, osr_name) + ) +) + +TRACEPOINT_EVENT(objectstore, omap_rmkeyrange_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, omap_rmkeys_enter, + TP_ARGS( + const char *, osr_name), + TP_FIELDS( + ctf_string(osr_name, osr_name) + ) +) + +TRACEPOINT_EVENT(objectstore, omap_rmkeys_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, omap_setkeys_enter, + TP_ARGS( + const char *, osr_name), + TP_FIELDS( + ctf_string(osr_name, osr_name) + ) +) + +TRACEPOINT_EVENT(objectstore, omap_setkeys_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, omap_clear_enter, + TP_ARGS( + const char *, osr_name), + TP_FIELDS( + ctf_string(osr_name, osr_name) + ) +) + +TRACEPOINT_EVENT(objectstore, omap_clear_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, coll_rmattr_enter, + TP_ARGS( + const char *, osr_name), + TP_FIELDS( + ctf_string(osr_name, osr_name) + ) +) + +TRACEPOINT_EVENT(objectstore, coll_rmattr_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, coll_setattr_enter, + TP_ARGS( + const char *, osr_name), + TP_FIELDS( + ctf_string(osr_name, osr_name) + ) +) + +TRACEPOINT_EVENT(objectstore, coll_setattr_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, coll_move_enter, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(objectstore, coll_move_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, coll_move_rename_enter, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(objectstore, coll_move_rename_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, coll_try_rename_enter, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(objectstore, coll_try_rename_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, coll_remove_enter, + TP_ARGS( + const char *, osr_name), + TP_FIELDS( + ctf_string(osr_name, osr_name) + ) +) + +TRACEPOINT_EVENT(objectstore, coll_remove_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, coll_add_enter, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(objectstore, coll_add_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, rmcoll_enter, + TP_ARGS( + const char *, osr_name), + TP_FIELDS( + ctf_string(osr_name, osr_name) + ) +) + +TRACEPOINT_EVENT(objectstore, rmcoll_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, mkcoll_enter, + TP_ARGS( + const char *, osr_name), + TP_FIELDS( + ctf_string(osr_name, osr_name) + ) +) + +TRACEPOINT_EVENT(objectstore, mkcoll_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, clone_range2_enter, + TP_ARGS( + const char *, osr_name, + uint64_t, length), + TP_FIELDS( + ctf_string(osr_name, osr_name) + ctf_integer(uint64_t, length, length) + ) +) + +TRACEPOINT_EVENT(objectstore, clone_range2_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, move_ranges_destroy_src_enter, + TP_ARGS( + const char *, osr_name), + TP_FIELDS( + ctf_string(osr_name, osr_name) + ) +) + +TRACEPOINT_EVENT(objectstore, move_ranges_destroy_src_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, clone_range_enter, + TP_ARGS( + const char *, osr_name, + uint64_t, length), + TP_FIELDS( + ctf_string(osr_name, osr_name) + ctf_integer(uint64_t, length, length) + ) +) + +TRACEPOINT_EVENT(objectstore, clone_range_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, clone_enter, + TP_ARGS( + const char *, osr_name), + TP_FIELDS( + ctf_string(osr_name, osr_name) + ) +) + +TRACEPOINT_EVENT(objectstore, clone_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, rmattrs_enter, + TP_ARGS( + const char *, osr_name), + TP_FIELDS( + ctf_string(osr_name, osr_name) + ) +) + +TRACEPOINT_EVENT(objectstore, rmattrs_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, rmattr_enter, + TP_ARGS( + const char *, osr_name), + TP_FIELDS( + ctf_string(osr_name, osr_name) + ) +) + +TRACEPOINT_EVENT(objectstore, rmattr_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, setattrs_enter, + TP_ARGS( + const char *, osr_name), + TP_FIELDS( + ctf_string(osr_name, osr_name) + ) +) + +TRACEPOINT_EVENT(objectstore, setattrs_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, setattr_enter, + TP_ARGS( + const char *, osr_name), + TP_FIELDS( + ctf_string(osr_name, osr_name) + ) +) + +TRACEPOINT_EVENT(objectstore, setattr_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, remove_enter, + TP_ARGS( + const char *, osr_name), + TP_FIELDS( + ctf_string(osr_name, osr_name) + ) +) + +TRACEPOINT_EVENT(objectstore, remove_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, truncate_enter, + TP_ARGS( + const char *, osr_name, + uint64_t, offset), + TP_FIELDS( + ctf_string(osr_name, osr_name) + ctf_integer(uint64_t, offset, offset) + ) +) + +TRACEPOINT_EVENT(objectstore, truncate_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, zero_enter, + TP_ARGS( + const char *, osr_name, + uint64_t, offset, + uint64_t, length), + TP_FIELDS( + ctf_string(osr_name, osr_name) + ctf_integer(uint64_t, offset, offset) + ctf_integer(uint64_t, length, length) + ) +) + +TRACEPOINT_EVENT(objectstore, zero_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(objectstore, touch_enter, + TP_ARGS( + const char *, osr_name), + TP_FIELDS( + ctf_string(osr_name, osr_name) + ) +) + +TRACEPOINT_EVENT(objectstore, touch_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) diff --git a/src/tracing/oprequest.c b/src/tracing/oprequest.c new file mode 100644 index 000000000..1daa37f83 --- /dev/null +++ b/src/tracing/oprequest.c @@ -0,0 +1,6 @@ + +#define TRACEPOINT_CREATE_PROBES +/* + * The header containing our TRACEPOINT_EVENTs. + */ +#include "tracing/oprequest.h" diff --git a/src/tracing/oprequest.tp b/src/tracing/oprequest.tp new file mode 100644 index 000000000..f81248663 --- /dev/null +++ b/src/tracing/oprequest.tp @@ -0,0 +1,47 @@ +#include "include/int_types.h" + +TRACEPOINT_EVENT(oprequest, set_rmw_flags, + TP_ARGS( + // osd_reqid_t + uint8_t, type, + int64_t, num, + uint64_t, tid, + int32_t, inc, + int, flag, + int, old_rmw_flags, + int, new_rmw_flags), + TP_FIELDS( + ctf_integer(uint8_t, type, type) + ctf_integer(int64_t, num, num) + ctf_integer(uint64_t, tid, tid) + ctf_integer(int32_t, inc, inc) + ctf_integer_hex(int, flag, flag) + ctf_integer_hex(int, old_rmw_flags, old_rmw_flags) + ctf_integer_hex(int, new_rmw_flags, new_rmw_flags) + ) +) + +TRACEPOINT_EVENT(oprequest, mark_flag_point, + TP_ARGS( + // osd_reqid_t + uint8_t, type, + int64_t, num, + uint64_t, tid, + int32_t, inc, + int, rmw_flags, + uint8_t, flag, + const char*, msg, + uint8_t, old_hit_flag_points, + uint8_t, new_hit_flag_points), + TP_FIELDS( + ctf_integer(uint8_t, type, type) + ctf_integer(int64_t, num, num) + ctf_integer(uint64_t, tid, tid) + ctf_integer(int32_t, inc, inc) + ctf_integer_hex(int, rmw_flags, rmw_flags) + ctf_integer_hex(uint8_t, flag, flag) + ctf_string(msg, msg) + ctf_integer_hex(uint8_t, old_hit_flag_points, old_hit_flag_points) + ctf_integer_hex(uint8_t, new_hit_flag_points, new_hit_flag_points) + ) +) diff --git a/src/tracing/osd.c b/src/tracing/osd.c new file mode 100644 index 000000000..5f6781491 --- /dev/null +++ b/src/tracing/osd.c @@ -0,0 +1,6 @@ + +#define TRACEPOINT_CREATE_PROBES +/* + * The header containing our TRACEPOINT_EVENTs. + */ +#include "tracing/osd.h" diff --git a/src/tracing/osd.tp b/src/tracing/osd.tp new file mode 100644 index 000000000..661a0f2cf --- /dev/null +++ b/src/tracing/osd.tp @@ -0,0 +1,836 @@ +#include "include/int_types.h" + +TRACEPOINT_EVENT(osd, prepare_tx_enter, + TP_ARGS( + // osd_reqid_t + uint8_t, type, + int64_t, num, + uint64_t, tid, + int32_t, inc), + TP_FIELDS( + ctf_integer(uint8_t, type, type) + ctf_integer(int64_t, num, num) + ctf_integer(uint64_t, tid, tid) + ctf_integer(int32_t, inc, inc) + ) +) + +TRACEPOINT_EVENT(osd, prepare_tx_exit, + TP_ARGS( + // osd_reqid_t + uint8_t, type, + int64_t, num, + uint64_t, tid, + int32_t, inc), + TP_FIELDS( + ctf_integer(uint8_t, type, type) + ctf_integer(int64_t, num, num) + ctf_integer(uint64_t, tid, tid) + ctf_integer(int32_t, inc, inc) + ) +) + +TRACEPOINT_EVENT(osd, ms_fast_dispatch, + TP_ARGS( + // osd_reqid_t + uint8_t, type, + int64_t, num, + uint64_t, tid, + int32_t, inc), + TP_FIELDS( + ctf_integer(uint8_t, type, type) + ctf_integer(int64_t, num, num) + ctf_integer(uint64_t, tid, tid) + ctf_integer(int32_t, inc, inc) + ) +) + +TRACEPOINT_EVENT(osd, opwq_process_start, + TP_ARGS( + // osd_reqid_t + uint8_t, type, + int64_t, num, + uint64_t, tid, + int32_t, inc), + TP_FIELDS( + ctf_integer(uint8_t, type, type) + ctf_integer(int64_t, num, num) + ctf_integer(uint64_t, tid, tid) + ctf_integer(int32_t, inc, inc) + ) +) + +TRACEPOINT_EVENT(osd, opwq_process_finish, + TP_ARGS( + // osd_reqid_t + uint8_t, type, + int64_t, num, + uint64_t, tid, + int32_t, inc), + TP_FIELDS( + ctf_integer(uint8_t, type, type) + ctf_integer(int64_t, num, num) + ctf_integer(uint64_t, tid, tid) + ctf_integer(int32_t, inc, inc) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre, + TP_ARGS( + const char*, oid, + uint64_t, snap, + uint16_t, op, + const char*, opname, + uint32_t, flags), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ctf_integer_hex(uint16_t, op, op) + ctf_string(opname, opname) + ctf_integer_hex(uint32_t, flags, flags) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_extent_cmp, + TP_ARGS( + const char*, oid, + uint64_t, snap, + uint64_t, osize, + uint32_t, oseq, + uint64_t, offset, + uint64_t, length, + uint64_t, truncate_size, + uint32_t, truncate_seq), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ctf_integer(uint64_t, osize, osize) + ctf_integer(uint32_t, oseq, oseq) + ctf_integer(uint64_t, offset, offset) + ctf_integer(uint64_t, length, length) + ctf_integer(uint64_t, truncate_size, truncate_size) + ctf_integer(uint32_t, truncate_seq, truncate_seq) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_read, + TP_ARGS( + const char*, oid, + uint64_t, snap, + uint64_t, osize, + uint32_t, oseq, + uint64_t, offset, + uint64_t, length, + uint64_t, truncate_size, + uint32_t, truncate_seq), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ctf_integer(uint64_t, osize, osize) + ctf_integer(uint32_t, oseq, oseq) + ctf_integer(uint64_t, offset, offset) + ctf_integer(uint64_t, length, length) + ctf_integer(uint64_t, truncate_size, truncate_size) + ctf_integer(uint32_t, truncate_seq, truncate_seq) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_checksum, + TP_ARGS( + const char*, oid, + uint64_t, snap, + uint64_t, osize, + uint32_t, oseq, + uint8_t, type, + uint64_t, offset, + uint64_t, length, + uint32_t, chunk_size), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ctf_integer(uint64_t, osize, osize) + ctf_integer(uint32_t, oseq, oseq) + ctf_integer(uint8_t, type, type) + ctf_integer(uint64_t, offset, offset) + ctf_integer(uint64_t, length, length) + ctf_integer(uint32_t, chunk_size, chunk_size) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_mapext, + TP_ARGS( + const char*, oid, + uint64_t, snap, + uint64_t, offset, + uint64_t, length), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ctf_integer(uint64_t, offset, offset) + ctf_integer(uint64_t, length, length) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_sparse_read, + TP_ARGS( + const char*, oid, + uint64_t, snap, + uint64_t, osize, + uint32_t, oseq, + uint64_t, offset, + uint64_t, length, + uint64_t, truncate_size, + uint32_t, truncate_seq), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ctf_integer(uint64_t, osize, osize) + ctf_integer(uint32_t, oseq, oseq) + ctf_integer(uint64_t, offset, offset) + ctf_integer(uint64_t, length, length) + ctf_integer(uint64_t, truncate_size, truncate_size) + ctf_integer(uint32_t, truncate_seq, truncate_seq) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_call, + TP_ARGS( + const char*, oid, + uint64_t, snap, + const char*, class_name, + const char*, method_name), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ctf_string(class_name, class_name) + ctf_string(method_name, method_name) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_stat, + TP_ARGS( + const char*, oid, + uint64_t, snap), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_isdirty, + TP_ARGS( + const char*, oid, + uint64_t, snap), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_undirty, + TP_ARGS( + const char*, oid, + uint64_t, snap), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_try_flush, + TP_ARGS( + const char*, oid, + uint64_t, snap), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_cache_flush, + TP_ARGS( + const char*, oid, + uint64_t, snap), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_cache_evict, + TP_ARGS( + const char*, oid, + uint64_t, snap), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_getxattr, + TP_ARGS( + const char*, oid, + uint64_t, snap, + const char*, aname), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ctf_string(aname, aname) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_getxattrs, + TP_ARGS( + const char*, oid, + uint64_t, snap), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_cmpxattr, + TP_ARGS( + const char*, oid, + uint64_t, snap, + const char*, aname), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ctf_string(aname, aname) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_assert_ver, + TP_ARGS( + const char*, oid, + uint64_t, snap, + uint64_t, ver), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ctf_integer(uint64_t, ver, ver) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_list_watchers, + TP_ARGS( + const char*, oid, + uint64_t, snap), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_list_snaps, + TP_ARGS( + const char*, oid, + uint64_t, snap), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_assert_src_version, + TP_ARGS( + const char*, oid, + uint64_t, snap, + uint64_t, ver), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ctf_integer(uint64_t, ver, ver) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_notify, + TP_ARGS( + const char*, oid, + uint64_t, snap, + uint64_t, timeout), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ctf_integer(uint64_t, timeout, timeout) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_notify_ack, + TP_ARGS( + const char*, oid, + uint64_t, snap, + uint64_t, notify_id, + uint64_t, watch_cookie, + const char*, watch_cookie_valid), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ctf_integer(uint64_t, notify_id, notify_id) + ctf_integer(uint64_t, watch_cookie, watch_cookie) + ctf_string(watch_cookie_valid, watch_cookie_valid) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_setallochint, + TP_ARGS( + const char*, oid, + uint64_t, snap, + uint64_t, expected_object_size, + uint64_t, expected_write_size), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ctf_integer(uint64_t, expected_object_size, expected_object_size) + ctf_integer(uint64_t, expected_write_size, expected_write_size) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_write, + TP_ARGS( + const char*, oid, + uint64_t, snap, + uint64_t, osize, + uint32_t, oseq, + uint64_t, offset, + uint64_t, length, + uint64_t, truncate_size, + uint32_t, truncate_seq), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ctf_integer(uint64_t, osize, osize) + ctf_integer(uint32_t, oseq, oseq) + ctf_integer(uint64_t, offset, offset) + ctf_integer(uint64_t, length, length) + ctf_integer(uint64_t, truncate_size, truncate_size) + ctf_integer(uint32_t, truncate_seq, truncate_seq) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_writefull, + TP_ARGS( + const char*, oid, + uint64_t, snap, + uint64_t, osize, + uint64_t, offset, + uint64_t, length), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ctf_integer(uint64_t, osize, osize) + ctf_integer(uint64_t, offset, offset) + ctf_integer(uint64_t, length, length) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_writesame, + TP_ARGS( + const char*, oid, + uint64_t, snap, + uint64_t, osize, + uint64_t, offset, + uint64_t, length, + uint64_t, data_length), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ctf_integer(uint64_t, osize, osize) + ctf_integer(uint64_t, offset, offset) + ctf_integer(uint64_t, length, length) + ctf_integer(uint64_t, data_length, data_length) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_rollback, + TP_ARGS( + const char*, oid, + uint64_t, snap), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_zero, + TP_ARGS( + const char*, oid, + uint64_t, snap, + uint64_t, offset, + uint64_t, length), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ctf_integer(uint64_t, offset, offset) + ctf_integer(uint64_t, length, length) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_create, + TP_ARGS( + const char*, oid, + uint64_t, snap), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_truncate, + TP_ARGS( + const char*, oid, + uint64_t, snap, + uint64_t, osize, + uint32_t, oseq, + uint64_t, offset, + uint64_t, length, + uint64_t, truncate_size, + uint32_t, truncate_seq), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ctf_integer(uint64_t, osize, osize) + ctf_integer(uint32_t, oseq, oseq) + ctf_integer(uint64_t, offset, offset) + ctf_integer(uint64_t, length, length) + ctf_integer(uint64_t, truncate_size, truncate_size) + ctf_integer(uint32_t, truncate_seq, truncate_seq) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_delete, + TP_ARGS( + const char*, oid, + uint64_t, snap), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_clonerange, + TP_ARGS( + const char*, oid, + uint64_t, snap, + uint64_t, offset, + uint64_t, length, + uint64_t, src_offset), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ctf_integer(uint64_t, offset, offset) + ctf_integer(uint64_t, length, length) + ctf_integer(uint64_t, src_offset, src_offset) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_watch, + TP_ARGS( + const char*, oid, + uint64_t, snap, + uint64_t, cookie, + uint8_t, op), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ctf_integer(uint64_t, cookie, cookie) + ctf_integer(uint8_t, op, op) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_cache_pin, + TP_ARGS( + const char*, oid, + uint64_t, snap), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_cache_unpin, + TP_ARGS( + const char*, oid, + uint64_t, snap), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_setxattr, + TP_ARGS( + const char*, oid, + uint64_t, snap, + const char*, aname), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ctf_string(aname, aname) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_rmxattr, + TP_ARGS( + const char*, oid, + uint64_t, snap, + const char*, aname), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ctf_string(aname, aname) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_append, + TP_ARGS( + const char*, oid, + uint64_t, snap, + uint64_t, osize, + uint32_t, oseq, + uint64_t, offset, + uint64_t, length, + uint64_t, truncate_size, + uint32_t, truncate_seq), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ctf_integer(uint64_t, osize, osize) + ctf_integer(uint32_t, oseq, oseq) + ctf_integer(uint64_t, offset, offset) + ctf_integer(uint64_t, length, length) + ctf_integer(uint64_t, truncate_size, truncate_size) + ctf_integer(uint32_t, truncate_seq, truncate_seq) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_tmapget, + TP_ARGS( + const char*, oid, + uint64_t, snap), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_tmapput, + TP_ARGS( + const char*, oid, + uint64_t, snap), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_tmapup, + TP_ARGS( + const char*, oid, + uint64_t, snap), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_tmap2omap, + TP_ARGS( + const char*, oid, + uint64_t, snap), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_omapgetkeys, + TP_ARGS( + const char*, oid, + uint64_t, snap, + const char*, start_after, + uint64_t, max_return), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ctf_string(start_after, start_after) + ctf_integer(uint64_t, max_return, max_return) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_omapgetvals, + TP_ARGS( + const char*, oid, + uint64_t, snap, + const char*, start_after, + uint64_t, max_return, + const char*, filter_prefix), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ctf_string(start_after, start_after) + ctf_integer(uint64_t, max_return, max_return) + ctf_string(filter_prefix, filter_prefix) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_omapgetheader, + TP_ARGS( + const char*, oid, + uint64_t, snap), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_omapgetvalsbykeys, + TP_ARGS( + const char*, oid, + uint64_t, snap, + const char*, keys), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ctf_string(keys, keys) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_omap_cmp, + TP_ARGS( + const char*, oid, + uint64_t, snap, + const char*, keys), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ctf_string(keys, keys) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_omapsetvals, + TP_ARGS( + const char*, oid, + uint64_t, snap), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_omapsetheader, + TP_ARGS( + const char*, oid, + uint64_t, snap), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_omapclear, + TP_ARGS( + const char*, oid, + uint64_t, snap), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_omaprmkeys, + TP_ARGS( + const char*, oid, + uint64_t, snap), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_omaprmkeyrange, + TP_ARGS( + const char*, oid, + uint64_t, snap), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_copy_get_classic, + TP_ARGS( + const char*, oid, + uint64_t, snap), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_copy_get, + TP_ARGS( + const char*, oid, + uint64_t, snap), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_copy_from, + TP_ARGS( + const char*, oid, + uint64_t, snap, + const char*, src_name, + int64_t, src_pool, + const char*, src_key, + const char*, src_nspace, + int64_t, src_hash, + uint64_t, src_snapid, + uint64_t, src_version), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ctf_string(src_name, src_name) + ctf_integer(int64_t, src_pool, src_pool) + ctf_string(src_key, src_key) + ctf_string(src_nspace, src_nspace) + ctf_integer(int64_t, src_hash, src_hash) + ctf_integer(uint64_t, src_snapid, src_snapid) + ctf_integer(uint64_t, src_version, src_version) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_pre_unknown, + TP_ARGS( + const char*, oid, + uint64_t, snap, + uint16_t, op, + const char*, opname), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ctf_integer_hex(uint16_t, op, op) + ctf_string(opname, opname) + ) +) + +TRACEPOINT_EVENT(osd, do_osd_op_post, + TP_ARGS( + const char*, oid, + uint64_t, snap, + uint16_t, op, + const char*, opname, + uint32_t, flags, + int, result), + TP_FIELDS( + ctf_string(oid, oid) + ctf_integer(uint64_t, snap, snap) + ctf_integer_hex(uint16_t, op, op) + ctf_string(opname, opname) + ctf_integer_hex(uint32_t, flags, flags) + ctf_integer_hex(int, result, result) + ) +) diff --git a/src/tracing/pg.c b/src/tracing/pg.c new file mode 100644 index 000000000..1373ed5e4 --- /dev/null +++ b/src/tracing/pg.c @@ -0,0 +1,6 @@ + +#define TRACEPOINT_CREATE_PROBES +/* + * The header containing our TRACEPOINT_EVENTs. + */ +#include "tracing/pg.h" diff --git a/src/tracing/pg.tp b/src/tracing/pg.tp new file mode 100644 index 000000000..264e7534d --- /dev/null +++ b/src/tracing/pg.tp @@ -0,0 +1,18 @@ +#include "include/int_types.h" + +TRACEPOINT_EVENT(pg, queue_op, + TP_ARGS( + // osd_reqid_t + uint8_t, type, + int64_t, num, + uint64_t, tid, + int32_t, inc, + int, rmw_flags), + TP_FIELDS( + ctf_integer(uint8_t, type, type) + ctf_integer(int64_t, num, num) + ctf_integer(uint64_t, tid, tid) + ctf_integer(int32_t, inc, inc) + ctf_integer(int, rmw_flags, rmw_flags) + ) +) diff --git a/src/tracing/rgw_op.c b/src/tracing/rgw_op.c new file mode 100644 index 000000000..0a3c1f96a --- /dev/null +++ b/src/tracing/rgw_op.c @@ -0,0 +1,6 @@ + +#define TRACEPOINT_CREATE_PROBES +/* + * The header containing our TRACEPOINT_EVENTs. + */ +#include "tracing/rgw_op.h" diff --git a/src/tracing/rgw_op.tp b/src/tracing/rgw_op.tp new file mode 100644 index 000000000..2d46d6b94 --- /dev/null +++ b/src/tracing/rgw_op.tp @@ -0,0 +1,36 @@ +#include "tracing/tracing-common.h" +#include "include/int_types.h" + +TRACEPOINT_EVENT(rgw_op, before_data_transfer, + TP_ARGS( + const char*, req_id), + TP_FIELDS( + ctf_string(req_id, req_id) + ) +) + +TRACEPOINT_EVENT(rgw_op, after_data_transfer, + TP_ARGS( + const char*, req_id, + long, ofs), + TP_FIELDS( + ctf_string(req_id, req_id) + ctf_integer(long, ofs, ofs) + ) +) + +TRACEPOINT_EVENT(rgw_op, processor_complete_enter, + TP_ARGS( + const char*, req_id), + TP_FIELDS( + ctf_string(req_id, req_id) + ) +) + +TRACEPOINT_EVENT(rgw_op, processor_complete_exit, + TP_ARGS( + const char*, req_id), + TP_FIELDS( + ctf_string(req_id, req_id) + ) +) diff --git a/src/tracing/rgw_rados.c b/src/tracing/rgw_rados.c new file mode 100644 index 000000000..e58b350d5 --- /dev/null +++ b/src/tracing/rgw_rados.c @@ -0,0 +1,6 @@ + +#define TRACEPOINT_CREATE_PROBES +/* + * The header containing our TRACEPOINT_EVENTs. + */ +#include "tracing/rgw_rados.h" diff --git a/src/tracing/rgw_rados.tp b/src/tracing/rgw_rados.tp new file mode 100644 index 000000000..14465f292 --- /dev/null +++ b/src/tracing/rgw_rados.tp @@ -0,0 +1,50 @@ +#include "tracing/tracing-common.h" +#include "include/int_types.h" + +TRACEPOINT_EVENT(rgw_rados, prepare_enter, + TP_ARGS( + const char*, req_id), + TP_FIELDS( + ctf_string(req_id, req_id) + ) +) + +TRACEPOINT_EVENT(rgw_rados, prepare_exit, + TP_ARGS( + const char*, req_id), + TP_FIELDS( + ctf_string(req_id, req_id) + ) +) + +TRACEPOINT_EVENT(rgw_rados, operate_enter, + TP_ARGS( + const char*, req_id), + TP_FIELDS( + ctf_string(req_id, req_id) + ) +) + +TRACEPOINT_EVENT(rgw_rados, operate_exit, + TP_ARGS( + const char*, req_id), + TP_FIELDS( + ctf_string(req_id, req_id) + ) +) + +TRACEPOINT_EVENT(rgw_rados, complete_enter, + TP_ARGS( + const char*, req_id), + TP_FIELDS( + ctf_string(req_id, req_id) + ) +) + +TRACEPOINT_EVENT(rgw_rados, complete_exit, + TP_ARGS( + const char*, req_id), + TP_FIELDS( + ctf_string(req_id, req_id) + ) +) diff --git a/src/tracing/tracing-common.h b/src/tracing/tracing-common.h new file mode 100644 index 000000000..3e07f9de8 --- /dev/null +++ b/src/tracing/tracing-common.h @@ -0,0 +1,102 @@ +#if !defined(TRACING_COMMON_H) +#define TRACING_COMMON_H + +// Amount of buffer data to dump when using ceph_ctf_sequence or ceph_ctf_sequencep. +// If 0, then *_data field is omitted entirely. +#if !defined(CEPH_TRACE_BUF_TRUNC_LEN) +#define CEPH_TRACE_BUF_TRUNC_LEN 0u +#endif + +// TODO: This is GCC-specific. Replace CEPH_MAX and CEPH_MIN with standard macros, if possible. +#define CEPH_MAX(a,b) \ + ({ __typeof__ (a) _a = (a); \ + __typeof__ (b) _b = (b); \ + _a > _b ? _a : _b; }) + +#define CEPH_MIN(a,b) \ + ({ __typeof__ (a) _a = (a); \ + __typeof__ (b) _b = (b); \ + _a < _b ? _a : _b; }) + +// type should be an integer type +// val should have type type* +#define ceph_ctf_integerp(type, field, val) \ + ctf_integer(type, field, (val) == NULL ? 0 : (val)) \ + ctf_integer(uint8_t, field##_isnull, (val) == NULL) + +// val should have type char* +#define ceph_ctf_string(field, val) \ + ctf_string(field, (val) == NULL ? "" : (val)) \ + ctf_integer(uint8_t, field##_isnull, (val) == NULL) + +// val should have type char** +#define ceph_ctf_stringp(field, val) \ + ctf_string(field, ((val) == NULL || *(val) == NULL) ? "" : *(val)) \ + ctf_integer(uint8_t, field##_isnull, (val) == NULL) \ + ctf_integer(uint8_t, field##_data_isnull, (val) == NULL || *(val) == NULL) + +// val should have type type* +// lenval should have type lentype +#if CEPH_TRACE_BUF_TRUNC_LEN > 0 +#define ceph_ctf_sequence(type, field, val, lentype, lenval) \ + ctf_integer_hex(void*, field, val) \ + ctf_sequence(type, field##_data, (val) == NULL ? "" : (val), lentype, (val) == NULL ? 0 : CEPH_MIN((lenval), CEPH_TRACE_BUF_TRUNC_LEN)) \ + ctf_integer(uint8_t, field##_isnull, (val) == NULL) \ + ctf_integer(lentype, field##_len, lenval) +#else +#define ceph_ctf_sequence(type, field, val, lentype, lenval) \ + ctf_integer_hex(void*, field, val) \ + ctf_integer(uint8_t, field##_isnull, (val) == NULL) \ + ctf_integer(lentype, field##_len, lenval) +#endif + +// val should have type type** +// lenval should have type lentype* +#if CEPH_TRACE_BUF_TRUNC_LEN > 0 +#define ceph_ctf_sequencep(type, field, val, lentype, lenval) \ + ctf_integer_hex(void*, field, val) \ + ctf_sequence(type, \ + field##_data, \ + ((val) == NULL || *(val) == NULL) ? "" : *(val), \ + lentype, \ + ((val) == NULL || *(val) == NULL || (lenval) == NULL) ? 0 : CEPH_MIN(*(lenval), CEPH_TRACE_BUF_TRUNC_LEN)) \ + ctf_integer(uint8_t, field##_isnull, (val) == NULL) \ + ctf_integer(uint8_t, field##_data_isnull, ((val) == NULL || *(val) == NULL)) \ + ctf_integer(lentype, field##_len, (lenval) == NULL ? 0 : *(lenval)) \ + ctf_integer(lentype, field##_len_isnull, (lenval) == NULL) +#else +#define ceph_ctf_sequencep(type, field, val, lentype, lenval) \ + ctf_integer_hex(void*, field, val) \ + ctf_integer(uint8_t, field##_isnull, (val) == NULL) \ + ctf_integer(uint8_t, field##_data_isnull, ((val) == NULL || *(val) == NULL)) \ + ctf_integer(lentype, field##_len, (lenval) == NULL ? 0 : *(lenval)) \ + ctf_integer(lentype, field##_len_isnull, (lenval) == NULL) +#endif + +// p should be of type struct timeval* +#define ceph_ctf_timevalp(field, p) \ + ctf_integer(long int, field##_sec, (p) == NULL ? 0 : (p)->tv_sec) \ + ctf_integer(long int, field##_usec, (p) == NULL ? 0 : (p)->tv_usec) \ + ctf_integer(uint8_t, field##_isnull, (p) == NULL) + +// p should be of type struct timespec* +#define ceph_ctf_timespecp(field, p) \ + ctf_integer(long int, field##_sec, (p) == NULL ? 0 : (p)->tv_sec) \ + ctf_integer(long int, field##_nsec, (p) == NULL ? 0 : (p)->tv_nsec) \ + ctf_integer(uint8_t, field##_isnull, (p) == NULL) + +// val should be of type time_t +// Currently assumes that time_t is an integer and no more than 64 bits wide. +// This is verified by the configure script. +#define ceph_ctf_time_t(field, val) \ + ctf_integer(uint64_t, field, (uint64_t)(val)) + +// val should be of type time_t* +// Currently assumes that time_t is an integer and no more than 64 bits wide. +// This is verified by the configure script. +#define ceph_ctf_time_tp(field, val) \ + ctf_integer(uint64_t, field, (val) == NULL ? 0 : (uint64_t)(*val)) \ + ctf_integer(uint8_t, field##_isnull, (val) == NULL) + + +#endif /* TRACING_COMMON_H */ -- cgit v1.2.3