Skip to content

Commit

Permalink
Switch to new style tracer
Browse files Browse the repository at this point in the history
  • Loading branch information
@netheril96
netheril96 committed Mar 13, 2024
1 parent 7c667c8 commit e47debe
Show file tree
Hide file tree
Showing 6 changed files with 439 additions and 425 deletions.
1 change: 1 addition & 0 deletions CMakeLists.txt
View file
Original file line number Diff line number Diff line change
Expand Up @@ -79,6 +79,7 @@ target_link_libraries(
securefs-static
PUBLIC uni-algo::uni-algo
absl::base
absl::time
absl::synchronization
absl::inlined_vector
absl::flat_hash_map
Expand Down
211 changes: 128 additions & 83 deletions sources/fuse_high_level_ops_base.cpp
View file
Original file line number Diff line number Diff line change
@@ -1,5 +1,5 @@
#include "fuse_high_level_ops_base.h"
#include "fuse_tracer.h"
#include "fuse_tracer_v2.h"
#include "logger.h"

#include <absl/functional/function_ref.h>
Expand All @@ -10,222 +10,262 @@ int FuseHighLevelOpsBase::static_statfs(const char* path, fuse_statvfs* buf)
{
auto ctx = fuse_get_context();
auto op = static_cast<FuseHighLevelOpsBase*>(ctx->private_data);
return FuseTracer::traced_call(
[=]() { return op->vstatfs(path, buf, ctx); }, "statfs", __LINE__, {{path}, {buf}});
return trace::FuseTracer::traced_call([=]() { return op->vstatfs(path, buf, ctx); },
"statfs",
__LINE__,
{{"path", {path}}, {"buf", {buf}}});
}
int FuseHighLevelOpsBase::static_getattr(const char* path, fuse_stat* st)
{
auto ctx = fuse_get_context();
auto op = static_cast<FuseHighLevelOpsBase*>(ctx->private_data);
return FuseTracer::traced_call(
[=]() { return op->vgetattr(path, st, ctx); }, "getattr", __LINE__, {{path}, {st}});
return trace::FuseTracer::traced_call([=]() { return op->vgetattr(path, st, ctx); },
"getattr",
__LINE__,
{{"path", {path}}, {"st", {st}}});
}
int FuseHighLevelOpsBase::static_fgetattr(const char* path, fuse_stat* st, fuse_file_info* info)
{
auto ctx = fuse_get_context();
auto op = static_cast<FuseHighLevelOpsBase*>(ctx->private_data);
return FuseTracer::traced_call([=]() { return op->vfgetattr(path, st, info, ctx); },
"fgetattr",
__LINE__,
{{path}, {st}, {info}});
return trace::FuseTracer::traced_call([=]() { return op->vfgetattr(path, st, info, ctx); },
"fgetattr",
__LINE__,
{{"path", {path}}, {"st", {st}}, {"info", {info}}});
}
int FuseHighLevelOpsBase::static_opendir(const char* path, fuse_file_info* info)
{
auto ctx = fuse_get_context();
auto op = static_cast<FuseHighLevelOpsBase*>(ctx->private_data);
return FuseTracer::traced_call(
[=]() { return op->vopendir(path, info, ctx); }, "opendir", __LINE__, {{path}, {info}});
return trace::FuseTracer::traced_call([=]() { return op->vopendir(path, info, ctx); },
"opendir",
__LINE__,
{{"path", {path}}, {"info", {info}}});
}
int FuseHighLevelOpsBase::static_releasedir(const char* path, fuse_file_info* info)
{
auto ctx = fuse_get_context();
auto op = static_cast<FuseHighLevelOpsBase*>(ctx->private_data);
return FuseTracer::traced_call([=]() { return op->vreleasedir(path, info, ctx); },
"releasedir",
__LINE__,
{{path}, {info}});
return trace::FuseTracer::traced_call([=]() { return op->vreleasedir(path, info, ctx); },
"releasedir",
__LINE__,
{{"path", {path}}, {"info", {info}}});
}
int FuseHighLevelOpsBase::static_readdir(
const char* path, void* buf, fuse_fill_dir_t filler, fuse_off_t off, fuse_file_info* info)
{
auto ctx = fuse_get_context();
auto op = static_cast<FuseHighLevelOpsBase*>(ctx->private_data);
return FuseTracer::traced_call([=]()
{ return op->vreaddir(path, buf, filler, off, info, ctx); },
"readdir",
__LINE__,
{{path}, {buf}, {&filler}, {&off}, {info}});
return trace::FuseTracer::traced_call(
[=]() { return op->vreaddir(path, buf, filler, off, info, ctx); },
"readdir",
__LINE__,
{{"path", {path}}, {"buf", {buf}}, {"filler", {filler}}, {"off", {off}}, {"info", {info}}});
}
int FuseHighLevelOpsBase::static_create(const char* path, fuse_mode_t mode, fuse_file_info* info)
{
auto ctx = fuse_get_context();
auto op = static_cast<FuseHighLevelOpsBase*>(ctx->private_data);
return FuseTracer::traced_call([=]() { return op->vcreate(path, mode, info, ctx); },
"create",
__LINE__,
{{path}, {&mode}, {info}});
return trace::FuseTracer::traced_call([=]() { return op->vcreate(path, mode, info, ctx); },
"create",
__LINE__,
{{"path", {path}}, {"mode", {mode}}, {"info", {info}}});
}
int FuseHighLevelOpsBase::static_open(const char* path, fuse_file_info* info)
{
auto ctx = fuse_get_context();
auto op = static_cast<FuseHighLevelOpsBase*>(ctx->private_data);
return FuseTracer::traced_call(
[=]() { return op->vopen(path, info, ctx); }, "open", __LINE__, {{path}, {info}});
return trace::FuseTracer::traced_call([=]() { return op->vopen(path, info, ctx); },
"open",
__LINE__,
{{"path", {path}}, {"info", {info}}});
}
int FuseHighLevelOpsBase::static_release(const char* path, fuse_file_info* info)
{
auto ctx = fuse_get_context();
auto op = static_cast<FuseHighLevelOpsBase*>(ctx->private_data);
return FuseTracer::traced_call(
[=]() { return op->vrelease(path, info, ctx); }, "release", __LINE__, {{path}, {info}});
return trace::FuseTracer::traced_call([=]() { return op->vrelease(path, info, ctx); },
"release",
__LINE__,
{{"path", {path}}, {"info", {info}}});
}
int FuseHighLevelOpsBase::static_read(
const char* path, char* buf, size_t size, fuse_off_t offset, fuse_file_info* info)
{
auto ctx = fuse_get_context();
auto op = static_cast<FuseHighLevelOpsBase*>(ctx->private_data);
return FuseTracer::traced_call(
[=]() { return op->vread(path, buf, size, offset, info, ctx); },
"read",
__LINE__,
{{path}, {static_cast<const void*>(buf)}, {&size}, {&offset}, {info}});
return trace::FuseTracer::traced_call([=]()
{ return op->vread(path, buf, size, offset, info, ctx); },
"read",
__LINE__,
{{"path", {path}},
{"buf", {static_cast<const void*>(buf)}},
{"size", {size}},
{"offset", {offset}},
{"info", {info}}});
}
int FuseHighLevelOpsBase::static_write(
const char* path, const char* buf, size_t size, fuse_off_t offset, fuse_file_info* info)
{
auto ctx = fuse_get_context();
auto op = static_cast<FuseHighLevelOpsBase*>(ctx->private_data);
return FuseTracer::traced_call(
return trace::FuseTracer::traced_call(
[=]() { return op->vwrite(path, buf, size, offset, info, ctx); },
"write",
__LINE__,
{{path}, {static_cast<const void*>(buf)}, {&size}, {&offset}, {info}});
{{"path", {path}},
{"buf", {static_cast<const void*>(buf)}},
{"size", {size}},
{"offset", {offset}},
{"info", {info}}});
}
int FuseHighLevelOpsBase::static_flush(const char* path, fuse_file_info* info)
{
auto ctx = fuse_get_context();
auto op = static_cast<FuseHighLevelOpsBase*>(ctx->private_data);
return FuseTracer::traced_call(
[=]() { return op->vflush(path, info, ctx); }, "flush", __LINE__, {{path}, {info}});
return trace::FuseTracer::traced_call([=]() { return op->vflush(path, info, ctx); },
"flush",
__LINE__,
{{"path", {path}}, {"info", {info}}});
}
int FuseHighLevelOpsBase::static_ftruncate(const char* path, fuse_off_t len, fuse_file_info* info)
{
auto ctx = fuse_get_context();
auto op = static_cast<FuseHighLevelOpsBase*>(ctx->private_data);
return FuseTracer::traced_call([=]() { return op->vftruncate(path, len, info, ctx); },
"ftruncate",
__LINE__,
{{path}, {&len}, {info}});
return trace::FuseTracer::traced_call([=]() { return op->vftruncate(path, len, info, ctx); },
"ftruncate",
__LINE__,
{{"path", {path}}, {"len", {len}}, {"info", {info}}});
}
int FuseHighLevelOpsBase::static_unlink(const char* path)
{
auto ctx = fuse_get_context();
auto op = static_cast<FuseHighLevelOpsBase*>(ctx->private_data);
return FuseTracer::traced_call(
[=]() { return op->vunlink(path, ctx); }, "unlink", __LINE__, {{path}});
return trace::FuseTracer::traced_call(
[=]() { return op->vunlink(path, ctx); }, "unlink", __LINE__, {{"path", {path}}});
}
int FuseHighLevelOpsBase::static_mkdir(const char* path, fuse_mode_t mode)
{
auto ctx = fuse_get_context();
auto op = static_cast<FuseHighLevelOpsBase*>(ctx->private_data);
return FuseTracer::traced_call(
[=]() { return op->vmkdir(path, mode, ctx); }, "mkdir", __LINE__, {{path}, {&mode}});
return trace::FuseTracer::traced_call([=]() { return op->vmkdir(path, mode, ctx); },
"mkdir",
__LINE__,
{{"path", {path}}, {"mode", {mode}}});
}
int FuseHighLevelOpsBase::static_rmdir(const char* path)
{
auto ctx = fuse_get_context();
auto op = static_cast<FuseHighLevelOpsBase*>(ctx->private_data);
return FuseTracer::traced_call(
[=]() { return op->vrmdir(path, ctx); }, "rmdir", __LINE__, {{path}});
return trace::FuseTracer::traced_call(
[=]() { return op->vrmdir(path, ctx); }, "rmdir", __LINE__, {{"path", {path}}});
}
int FuseHighLevelOpsBase::static_chmod(const char* path, fuse_mode_t mode)
{
auto ctx = fuse_get_context();
auto op = static_cast<FuseHighLevelOpsBase*>(ctx->private_data);
return FuseTracer::traced_call(
[=]() { return op->vchmod(path, mode, ctx); }, "chmod", __LINE__, {{path}, {&mode}});
return trace::FuseTracer::traced_call([=]() { return op->vchmod(path, mode, ctx); },
"chmod",
__LINE__,
{{"path", {path}}, {"mode", {mode}}});
}
int FuseHighLevelOpsBase::static_chown(const char* path, fuse_uid_t uid, fuse_gid_t gid)
{
auto ctx = fuse_get_context();
auto op = static_cast<FuseHighLevelOpsBase*>(ctx->private_data);
return FuseTracer::traced_call([=]() { return op->vchown(path, uid, gid, ctx); },
"chown",
__LINE__,
{{path}, {&uid}, {&gid}});
return trace::FuseTracer::traced_call([=]() { return op->vchown(path, uid, gid, ctx); },
"chown",
__LINE__,
{{"path", {path}}, {"uid", {uid}}, {"gid", {gid}}});
}
int FuseHighLevelOpsBase::static_symlink(const char* to, const char* from)
{
auto ctx = fuse_get_context();
auto op = static_cast<FuseHighLevelOpsBase*>(ctx->private_data);
return FuseTracer::traced_call(
[=]() { return op->vsymlink(to, from, ctx); }, "symlink", __LINE__, {{to}, {from}});
return trace::FuseTracer::traced_call([=]() { return op->vsymlink(to, from, ctx); },
"symlink",
__LINE__,
{{"to", {to}}, {"from", {from}}});
}
int FuseHighLevelOpsBase::static_link(const char* src, const char* dest)
{
auto ctx = fuse_get_context();
auto op = static_cast<FuseHighLevelOpsBase*>(ctx->private_data);
return FuseTracer::traced_call(
[=]() { return op->vlink(src, dest, ctx); }, "link", __LINE__, {{src}, {dest}});
return trace::FuseTracer::traced_call([=]() { return op->vlink(src, dest, ctx); },
"link",
__LINE__,
{{"src", {src}}, {"dest", {dest}}});
}
int FuseHighLevelOpsBase::static_readlink(const char* path, char* buf, size_t size)
{
auto ctx = fuse_get_context();
auto op = static_cast<FuseHighLevelOpsBase*>(ctx->private_data);
return FuseTracer::traced_call([=]() { return op->vreadlink(path, buf, size, ctx); },
"readlink",
__LINE__,
{{path}, {static_cast<const void*>(buf)}, {&size}});
return trace::FuseTracer::traced_call(
[=]() { return op->vreadlink(path, buf, size, ctx); },
"readlink",
__LINE__,
{{"path", {path}}, {"buf", {static_cast<const void*>(buf)}}, {"size", {size}}});
}
int FuseHighLevelOpsBase::static_rename(const char* from, const char* to)
{
auto ctx = fuse_get_context();
auto op = static_cast<FuseHighLevelOpsBase*>(ctx->private_data);
return FuseTracer::traced_call(
[=]() { return op->vrename(from, to, ctx); }, "rename", __LINE__, {{from}, {to}});
return trace::FuseTracer::traced_call([=]() { return op->vrename(from, to, ctx); },
"rename",
__LINE__,
{{"from", {from}}, {"to", {to}}});
}
int FuseHighLevelOpsBase::static_fsync(const char* path, int datasync, fuse_file_info* info)
{
auto ctx = fuse_get_context();
auto op = static_cast<FuseHighLevelOpsBase*>(ctx->private_data);
return FuseTracer::traced_call([=]() { return op->vfsync(path, datasync, info, ctx); },
"fsync",
__LINE__,
{{path}, {&datasync}, {info}});
return trace::FuseTracer::traced_call(
[=]() { return op->vfsync(path, datasync, info, ctx); },
"fsync",
__LINE__,
{{"path", {path}}, {"datasync", {datasync}}, {"info", {info}}});
}
int FuseHighLevelOpsBase::static_truncate(const char* path, fuse_off_t len)
{
auto ctx = fuse_get_context();
auto op = static_cast<FuseHighLevelOpsBase*>(ctx->private_data);
return FuseTracer::traced_call(
[=]() { return op->vtruncate(path, len, ctx); }, "truncate", __LINE__, {{path}, {&len}});
return trace::FuseTracer::traced_call([=]() { return op->vtruncate(path, len, ctx); },
"truncate",
__LINE__,
{{"path", {path}}, {"len", {len}}});
}
int FuseHighLevelOpsBase::static_utimens(const char* path, const fuse_timespec* ts)
{
auto ctx = fuse_get_context();
auto op = static_cast<FuseHighLevelOpsBase*>(ctx->private_data);
return FuseTracer::traced_call(
[=]() { return op->vutimens(path, ts, ctx); }, "utimens", __LINE__, {{path}, {ts}});
return trace::FuseTracer::traced_call([=]() { return op->vutimens(path, ts, ctx); },
"utimens",
__LINE__,
{{"path", {path}}, {"ts", {ts}}});
}
int FuseHighLevelOpsBase::static_listxattr(const char* path, char* list, size_t size)
{
auto ctx = fuse_get_context();
auto op = static_cast<FuseHighLevelOpsBase*>(ctx->private_data);
return FuseTracer::traced_call([=]() { return op->vlistxattr(path, list, size, ctx); },
"listxattr",
__LINE__,
{{path}, {list}, {&size}});
return trace::FuseTracer::traced_call([=]() { return op->vlistxattr(path, list, size, ctx); },
"listxattr",
__LINE__,
{{"path", {path}}, {"list", {list}}, {"size", {size}}});
}
int FuseHighLevelOpsBase::static_getxattr(
const char* path, const char* name, char* value, size_t size, uint32_t position)
{
auto ctx = fuse_get_context();
auto op = static_cast<FuseHighLevelOpsBase*>(ctx->private_data);
return FuseTracer::traced_call(
return trace::FuseTracer::traced_call(
[=]() { return op->vgetxattr(path, name, value, size, position, ctx); },
"getxattr",
__LINE__,
{{path}, {name}, {value}, {&size}, {&position}});
{{"path", {path}},
{"name", {name}},
{"value", {value}},
{"size", {size}},
{"position", {position}}});
}
int FuseHighLevelOpsBase::static_setxattr(const char* path,
const char* name,
Expand All @@ -236,20 +276,25 @@ int FuseHighLevelOpsBase::static_setxattr(const char* path,
{
auto ctx = fuse_get_context();
auto op = static_cast<FuseHighLevelOpsBase*>(ctx->private_data);
return FuseTracer::traced_call(
return trace::FuseTracer::traced_call(
[=]() { return op->vsetxattr(path, name, value, size, flags, position, ctx); },
"setxattr",
__LINE__,
{{path}, {name}, {value}, {&size}, {&flags}, {&position}});
{{"path", {path}},
{"name", {name}},
{"value", {value}},
{"size", {size}},
{"flags", {flags}},
{"position", {position}}});
}
int FuseHighLevelOpsBase::static_removexattr(const char* path, const char* name)
{
auto ctx = fuse_get_context();
auto op = static_cast<FuseHighLevelOpsBase*>(ctx->private_data);
return FuseTracer::traced_call([=]() { return op->vremovexattr(path, name, ctx); },
"removexattr",
__LINE__,
{{path}, {name}});
return trace::FuseTracer::traced_call([=]() { return op->vremovexattr(path, name, ctx); },
"removexattr",
__LINE__,
{{"path", {path}}, {"name", {name}}});
}

fuse_operations FuseHighLevelOpsBase::build_ops(bool enable_xattr)
Expand Down
Loading

0 comments on commit e47debe

Please sign in to comment.