ceph/src/rocksdb/env/file_system_tracer.cc

   1 // Copyright (c) 2019-present, Facebook, Inc.  All rights reserved.
   2 // This source code is licensed under both the GPLv2 (found in the
   3 //  COPYING file in the root directory) and Apache 2.0 License
   4 //  (found in the LICENSE.Apache file in the root directory).
   5
   6 #include "env/file_system_tracer.h"
   7
   8 #include "rocksdb/file_system.h"
   9 #include "rocksdb/system_clock.h"
  10 #include "rocksdb/trace_record.h"
  11
  12 namespace ROCKSDB_NAMESPACE {
  13
  14 IOStatus FileSystemTracingWrapper::NewSequentialFile(
  15     const std::string& fname, const FileOptions& file_opts,
  16     std::unique_ptr<FSSequentialFile>* result, IODebugContext* dbg) {
  17   StopWatchNano timer(clock_);
  18   timer.Start();
  19   IOStatus s = target()->NewSequentialFile(fname, file_opts, result, dbg);
  20   uint64_t elapsed = timer.ElapsedNanos();
  21   IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer,
  22                           0 /*io_op_data*/, __func__, elapsed, s.ToString(),
  23                           fname.substr(fname.find_last_of("/\\") + 1));
  24   io_tracer_->WriteIOOp(io_record, dbg);
  25   return s;
  26 }
  27
  28 IOStatus FileSystemTracingWrapper::NewRandomAccessFile(
  29     const std::string& fname, const FileOptions& file_opts,
  30     std::unique_ptr<FSRandomAccessFile>* result, IODebugContext* dbg) {
  31   StopWatchNano timer(clock_);
  32   timer.Start();
  33   IOStatus s = target()->NewRandomAccessFile(fname, file_opts, result, dbg);
  34   uint64_t elapsed = timer.ElapsedNanos();
  35   IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer,
  36                           0 /*io_op_data*/, __func__, elapsed, s.ToString(),
  37                           fname.substr(fname.find_last_of("/\\") + 1));
  38   io_tracer_->WriteIOOp(io_record, dbg);
  39   return s;
  40 }
  41
  42 IOStatus FileSystemTracingWrapper::NewWritableFile(
  43     const std::string& fname, const FileOptions& file_opts,
  44     std::unique_ptr<FSWritableFile>* result, IODebugContext* dbg) {
  45   StopWatchNano timer(clock_);
  46   timer.Start();
  47   IOStatus s = target()->NewWritableFile(fname, file_opts, result, dbg);
  48   uint64_t elapsed = timer.ElapsedNanos();
  49   IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer,
  50                           0 /*io_op_data*/, __func__, elapsed, s.ToString(),
  51                           fname.substr(fname.find_last_of("/\\") + 1));
  52   io_tracer_->WriteIOOp(io_record, dbg);
  53   return s;
  54 }
  55
  56 IOStatus FileSystemTracingWrapper::ReopenWritableFile(
  57     const std::string& fname, const FileOptions& file_opts,
  58     std::unique_ptr<FSWritableFile>* result, IODebugContext* dbg) {
  59   StopWatchNano timer(clock_);
  60   timer.Start();
  61   IOStatus s = target()->ReopenWritableFile(fname, file_opts, result, dbg);
  62   uint64_t elapsed = timer.ElapsedNanos();
  63   IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer,
  64                           0 /*io_op_data*/, __func__, elapsed, s.ToString(),
  65                           fname.substr(fname.find_last_of("/\\") + 1));
  66   io_tracer_->WriteIOOp(io_record, dbg);
  67   return s;
  68 }
  69
  70 IOStatus FileSystemTracingWrapper::ReuseWritableFile(
  71     const std::string& fname, const std::string& old_fname,
  72     const FileOptions& file_opts, std::unique_ptr<FSWritableFile>* result,
  73     IODebugContext* dbg) {
  74   StopWatchNano timer(clock_);
  75   timer.Start();
  76   IOStatus s =
  77       target()->ReuseWritableFile(fname, old_fname, file_opts, result, dbg);
  78   uint64_t elapsed = timer.ElapsedNanos();
  79   IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer,
  80                           0 /*io_op_data*/, __func__, elapsed, s.ToString(),
  81                           fname.substr(fname.find_last_of("/\\") + 1));
  82   io_tracer_->WriteIOOp(io_record, dbg);
  83   return s;
  84 }
  85
  86 IOStatus FileSystemTracingWrapper::NewRandomRWFile(
  87     const std::string& fname, const FileOptions& file_opts,
  88     std::unique_ptr<FSRandomRWFile>* result, IODebugContext* dbg) {
  89   StopWatchNano timer(clock_);
  90   timer.Start();
  91   IOStatus s = target()->NewRandomRWFile(fname, file_opts, result, dbg);
  92   uint64_t elapsed = timer.ElapsedNanos();
  93   IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer,
  94                           0 /*io_op_data*/, __func__, elapsed, s.ToString(),
  95                           fname.substr(fname.find_last_of("/\\") + 1));
  96   io_tracer_->WriteIOOp(io_record, dbg);
  97   return s;
  98 }
  99
 100 IOStatus FileSystemTracingWrapper::NewDirectory(
 101     const std::string& name, const IOOptions& io_opts,
 102     std::unique_ptr<FSDirectory>* result, IODebugContext* dbg) {
 103   StopWatchNano timer(clock_);
 104   timer.Start();
 105   IOStatus s = target()->NewDirectory(name, io_opts, result, dbg);
 106   uint64_t elapsed = timer.ElapsedNanos();
 107   IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer,
 108                           0 /*io_op_data*/, __func__, elapsed, s.ToString(),
 109                           name.substr(name.find_last_of("/\\") + 1));
 110   io_tracer_->WriteIOOp(io_record, dbg);
 111   return s;
 112 }
 113
 114 IOStatus FileSystemTracingWrapper::GetChildren(const std::string& dir,
 115                                                const IOOptions& io_opts,
 116                                                std::vector<std::string>* r,
 117                                                IODebugContext* dbg) {
 118   StopWatchNano timer(clock_);
 119   timer.Start();
 120   IOStatus s = target()->GetChildren(dir, io_opts, r, dbg);
 121   uint64_t elapsed = timer.ElapsedNanos();
 122   IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer,
 123                           0 /*io_op_data*/, __func__, elapsed, s.ToString(),
 124                           dir.substr(dir.find_last_of("/\\") + 1));
 125   io_tracer_->WriteIOOp(io_record, dbg);
 126   return s;
 127 }
 128
 129 IOStatus FileSystemTracingWrapper::DeleteFile(const std::string& fname,
 130                                               const IOOptions& options,
 131                                               IODebugContext* dbg) {
 132   StopWatchNano timer(clock_);
 133   timer.Start();
 134   IOStatus s = target()->DeleteFile(fname, options, dbg);
 135   uint64_t elapsed = timer.ElapsedNanos();
 136   IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer,
 137                           0 /*io_op_data*/, __func__, elapsed, s.ToString(),
 138                           fname.substr(fname.find_last_of("/\\") + 1));
 139   io_tracer_->WriteIOOp(io_record, dbg);
 140   return s;
 141 }
 142
 143 IOStatus FileSystemTracingWrapper::CreateDir(const std::string& dirname,
 144                                              const IOOptions& options,
 145                                              IODebugContext* dbg) {
 146   StopWatchNano timer(clock_);
 147   timer.Start();
 148   IOStatus s = target()->CreateDir(dirname, options, dbg);
 149   uint64_t elapsed = timer.ElapsedNanos();
 150   IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer,
 151                           0 /*io_op_data*/, __func__, elapsed, s.ToString(),
 152                           dirname.substr(dirname.find_last_of("/\\") + 1));
 153   io_tracer_->WriteIOOp(io_record, dbg);
 154   return s;
 155 }
 156
 157 IOStatus FileSystemTracingWrapper::CreateDirIfMissing(
 158     const std::string& dirname, const IOOptions& options, IODebugContext* dbg) {
 159   StopWatchNano timer(clock_);
 160   timer.Start();
 161   IOStatus s = target()->CreateDirIfMissing(dirname, options, dbg);
 162   uint64_t elapsed = timer.ElapsedNanos();
 163   IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer,
 164                           0 /*io_op_data*/, __func__, elapsed, s.ToString(),
 165                           dirname.substr(dirname.find_last_of("/\\") + 1));
 166   io_tracer_->WriteIOOp(io_record, dbg);
 167   return s;
 168 }
 169
 170 IOStatus FileSystemTracingWrapper::DeleteDir(const std::string& dirname,
 171                                              const IOOptions& options,
 172                                              IODebugContext* dbg) {
 173   StopWatchNano timer(clock_);
 174   timer.Start();
 175   IOStatus s = target()->DeleteDir(dirname, options, dbg);
 176   uint64_t elapsed = timer.ElapsedNanos();
 177   IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer,
 178                           0 /*io_op_data*/, __func__, elapsed, s.ToString(),
 179                           dirname.substr(dirname.find_last_of("/\\") + 1));
 180   io_tracer_->WriteIOOp(io_record, dbg);
 181   return s;
 182 }
 183
 184 IOStatus FileSystemTracingWrapper::GetFileSize(const std::string& fname,
 185                                                const IOOptions& options,
 186                                                uint64_t* file_size,
 187                                                IODebugContext* dbg) {
 188   StopWatchNano timer(clock_);
 189   timer.Start();
 190   IOStatus s = target()->GetFileSize(fname, options, file_size, dbg);
 191   uint64_t elapsed = timer.ElapsedNanos();
 192   uint64_t io_op_data = 0;
 193   io_op_data |= (1 << IOTraceOp::kIOFileSize);
 194   IOTraceRecord io_record(
 195       clock_->NowNanos(), TraceType::kIOTracer, io_op_data, __func__, elapsed,
 196       s.ToString(), fname.substr(fname.find_last_of("/\\") + 1), *file_size);
 197   io_tracer_->WriteIOOp(io_record, dbg);
 198   return s;
 199 }
 200
 201 IOStatus FileSystemTracingWrapper::Truncate(const std::string& fname,
 202                                             size_t size,
 203                                             const IOOptions& options,
 204                                             IODebugContext* dbg) {
 205   StopWatchNano timer(clock_);
 206   timer.Start();
 207   IOStatus s = target()->Truncate(fname, size, options, dbg);
 208   uint64_t elapsed = timer.ElapsedNanos();
 209   uint64_t io_op_data = 0;
 210   io_op_data |= (1 << IOTraceOp::kIOFileSize);
 211   IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer, io_op_data,
 212                           __func__, elapsed, s.ToString(),
 213                           fname.substr(fname.find_last_of("/\\") + 1), size);
 214   io_tracer_->WriteIOOp(io_record, dbg);
 215   return s;
 216 }
 217
 218 IOStatus FSSequentialFileTracingWrapper::Read(size_t n,
 219                                               const IOOptions& options,
 220                                               Slice* result, char* scratch,
 221                                               IODebugContext* dbg) {
 222   StopWatchNano timer(clock_);
 223   timer.Start();
 224   IOStatus s = target()->Read(n, options, result, scratch, dbg);
 225   uint64_t elapsed = timer.ElapsedNanos();
 226   uint64_t io_op_data = 0;
 227   io_op_data |= (1 << IOTraceOp::kIOLen);
 228   IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer, io_op_data,
 229                           __func__, elapsed, s.ToString(), file_name_,
 230                           result->size(), 0 /*Offset*/);
 231   io_tracer_->WriteIOOp(io_record, dbg);
 232   return s;
 233 }
 234
 235 IOStatus FSSequentialFileTracingWrapper::InvalidateCache(size_t offset,
 236                                                          size_t length) {
 237   StopWatchNano timer(clock_);
 238   timer.Start();
 239   IOStatus s = target()->InvalidateCache(offset, length);
 240   uint64_t elapsed = timer.ElapsedNanos();
 241   uint64_t io_op_data = 0;
 242   io_op_data |= (1 << IOTraceOp::kIOLen);
 243   io_op_data |= (1 << IOTraceOp::kIOOffset);
 244   IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer, io_op_data,
 245                           __func__, elapsed, s.ToString(), file_name_, length,
 246                           offset);
 247   io_tracer_->WriteIOOp(io_record, nullptr /*dbg*/);
 248   return s;
 249 }
 250
 251 IOStatus FSSequentialFileTracingWrapper::PositionedRead(
 252     uint64_t offset, size_t n, const IOOptions& options, Slice* result,
 253     char* scratch, IODebugContext* dbg) {
 254   StopWatchNano timer(clock_);
 255   timer.Start();
 256   IOStatus s =
 257       target()->PositionedRead(offset, n, options, result, scratch, dbg);
 258   uint64_t elapsed = timer.ElapsedNanos();
 259   uint64_t io_op_data = 0;
 260   io_op_data |= (1 << IOTraceOp::kIOLen);
 261   io_op_data |= (1 << IOTraceOp::kIOOffset);
 262   IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer, io_op_data,
 263                           __func__, elapsed, s.ToString(), file_name_,
 264                           result->size(), offset);
 265   io_tracer_->WriteIOOp(io_record, dbg);
 266   return s;
 267 }
 268
 269 IOStatus FSRandomAccessFileTracingWrapper::Read(uint64_t offset, size_t n,
 270                                                 const IOOptions& options,
 271                                                 Slice* result, char* scratch,
 272                                                 IODebugContext* dbg) const {
 273   StopWatchNano timer(clock_);
 274   timer.Start();
 275   IOStatus s = target()->Read(offset, n, options, result, scratch, dbg);
 276   uint64_t elapsed = timer.ElapsedNanos();
 277   uint64_t io_op_data = 0;
 278   io_op_data |= (1 << IOTraceOp::kIOLen);
 279   io_op_data |= (1 << IOTraceOp::kIOOffset);
 280   IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer, io_op_data,
 281                           __func__, elapsed, s.ToString(), file_name_, n,
 282                           offset);
 283   io_tracer_->WriteIOOp(io_record, dbg);
 284   return s;
 285 }
 286
 287 IOStatus FSRandomAccessFileTracingWrapper::MultiRead(FSReadRequest* reqs,
 288                                                      size_t num_reqs,
 289                                                      const IOOptions& options,
 290                                                      IODebugContext* dbg) {
 291   StopWatchNano timer(clock_);
 292   timer.Start();
 293   IOStatus s = target()->MultiRead(reqs, num_reqs, options, dbg);
 294   uint64_t elapsed = timer.ElapsedNanos();
 295   uint64_t latency = elapsed;
 296   uint64_t io_op_data = 0;
 297   io_op_data |= (1 << IOTraceOp::kIOLen);
 298   io_op_data |= (1 << IOTraceOp::kIOOffset);
 299   for (size_t i = 0; i < num_reqs; i++) {
 300     IOTraceRecord io_record(
 301         clock_->NowNanos(), TraceType::kIOTracer, io_op_data, __func__, latency,
 302         reqs[i].status.ToString(), file_name_, reqs[i].len, reqs[i].offset);
 303     io_tracer_->WriteIOOp(io_record, dbg);
 304   }
 305   return s;
 306 }
 307
 308 IOStatus FSRandomAccessFileTracingWrapper::Prefetch(uint64_t offset, size_t n,
 309                                                     const IOOptions& options,
 310                                                     IODebugContext* dbg) {
 311   StopWatchNano timer(clock_);
 312   timer.Start();
 313   IOStatus s = target()->Prefetch(offset, n, options, dbg);
 314   uint64_t elapsed = timer.ElapsedNanos();
 315   uint64_t io_op_data = 0;
 316   io_op_data |= (1 << IOTraceOp::kIOLen);
 317   io_op_data |= (1 << IOTraceOp::kIOOffset);
 318   IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer, io_op_data,
 319                           __func__, elapsed, s.ToString(), file_name_, n,
 320                           offset);
 321   io_tracer_->WriteIOOp(io_record, dbg);
 322   return s;
 323 }
 324
 325 IOStatus FSRandomAccessFileTracingWrapper::InvalidateCache(size_t offset,
 326                                                            size_t length) {
 327   StopWatchNano timer(clock_);
 328   timer.Start();
 329   IOStatus s = target()->InvalidateCache(offset, length);
 330   uint64_t elapsed = timer.ElapsedNanos();
 331   uint64_t io_op_data = 0;
 332   io_op_data |= (1 << IOTraceOp::kIOLen);
 333   io_op_data |= (1 << IOTraceOp::kIOOffset);
 334   IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer, io_op_data,
 335                           __func__, elapsed, s.ToString(), file_name_, length,
 336                           static_cast<uint64_t>(offset));
 337   io_tracer_->WriteIOOp(io_record, nullptr /*dbg*/);
 338   return s;
 339 }
 340
 341 IOStatus FSRandomAccessFileTracingWrapper::ReadAsync(
 342     FSReadRequest& req, const IOOptions& opts,
 343     std::function<void(const FSReadRequest&, void*)> cb, void* cb_arg,
 344     void** io_handle, IOHandleDeleter* del_fn, IODebugContext* dbg) {
 345   // Create a callback and populate info.
 346   auto read_async_callback =
 347       std::bind(&FSRandomAccessFileTracingWrapper::ReadAsyncCallback, this,
 348                 std::placeholders::_1, std::placeholders::_2);
 349   ReadAsyncCallbackInfo* read_async_cb_info = new ReadAsyncCallbackInfo;
 350   read_async_cb_info->cb_ = cb;
 351   read_async_cb_info->cb_arg_ = cb_arg;
 352   read_async_cb_info->start_time_ = clock_->NowNanos();
 353   read_async_cb_info->file_op_ = __func__;
 354
 355   IOStatus s = target()->ReadAsync(req, opts, read_async_callback,
 356                                    read_async_cb_info, io_handle, del_fn, dbg);
 357
 358   if (!s.ok()) {
 359     delete read_async_cb_info;
 360   }
 361   return s;
 362 }
 363
 364 void FSRandomAccessFileTracingWrapper::ReadAsyncCallback(
 365     const FSReadRequest& req, void* cb_arg) {
 366   ReadAsyncCallbackInfo* read_async_cb_info =
 367       static_cast<ReadAsyncCallbackInfo*>(cb_arg);
 368   assert(read_async_cb_info);
 369   assert(read_async_cb_info->cb_);
 370
 371   uint64_t elapsed = clock_->NowNanos() - read_async_cb_info->start_time_;
 372   uint64_t io_op_data = 0;
 373   io_op_data |= (1 << IOTraceOp::kIOLen);
 374   io_op_data |= (1 << IOTraceOp::kIOOffset);
 375   IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer, io_op_data,
 376                           read_async_cb_info->file_op_, elapsed,
 377                           req.status.ToString(), file_name_, req.result.size(),
 378                           req.offset);
 379   io_tracer_->WriteIOOp(io_record, nullptr /*dbg*/);
 380
 381   // call the underlying callback.
 382   read_async_cb_info->cb_(req, read_async_cb_info->cb_arg_);
 383   delete read_async_cb_info;
 384 }
 385
 386 IOStatus FSWritableFileTracingWrapper::Append(const Slice& data,
 387                                               const IOOptions& options,
 388                                               IODebugContext* dbg) {
 389   StopWatchNano timer(clock_);
 390   timer.Start();
 391   IOStatus s = target()->Append(data, options, dbg);
 392   uint64_t elapsed = timer.ElapsedNanos();
 393   uint64_t io_op_data = 0;
 394   io_op_data |= (1 << IOTraceOp::kIOLen);
 395   IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer, io_op_data,
 396                           __func__, elapsed, s.ToString(), file_name_,
 397                           data.size(), 0 /*Offset*/);
 398   io_tracer_->WriteIOOp(io_record, dbg);
 399   return s;
 400 }
 401
 402 IOStatus FSWritableFileTracingWrapper::PositionedAppend(
 403     const Slice& data, uint64_t offset, const IOOptions& options,
 404     IODebugContext* dbg) {
 405   StopWatchNano timer(clock_);
 406   timer.Start();
 407   IOStatus s = target()->PositionedAppend(data, offset, options, dbg);
 408   uint64_t elapsed = timer.ElapsedNanos();
 409   uint64_t io_op_data = 0;
 410   io_op_data |= (1 << IOTraceOp::kIOLen);
 411   io_op_data |= (1 << IOTraceOp::kIOOffset);
 412   IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer, io_op_data,
 413                           __func__, elapsed, s.ToString(), file_name_,
 414                           data.size(), offset);
 415   io_tracer_->WriteIOOp(io_record, dbg);
 416   return s;
 417 }
 418
 419 IOStatus FSWritableFileTracingWrapper::Truncate(uint64_t size,
 420                                                 const IOOptions& options,
 421                                                 IODebugContext* dbg) {
 422   StopWatchNano timer(clock_);
 423   timer.Start();
 424   IOStatus s = target()->Truncate(size, options, dbg);
 425   uint64_t elapsed = timer.ElapsedNanos();
 426   uint64_t io_op_data = 0;
 427   io_op_data |= (1 << IOTraceOp::kIOLen);
 428   IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer, io_op_data,
 429                           __func__, elapsed, s.ToString(), file_name_, size,
 430                           0 /*Offset*/);
 431   io_tracer_->WriteIOOp(io_record, dbg);
 432   return s;
 433 }
 434
 435 IOStatus FSWritableFileTracingWrapper::Close(const IOOptions& options,
 436                                              IODebugContext* dbg) {
 437   StopWatchNano timer(clock_);
 438   timer.Start();
 439   IOStatus s = target()->Close(options, dbg);
 440   uint64_t elapsed = timer.ElapsedNanos();
 441   IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer,
 442                           0 /*io_op_data*/, __func__, elapsed, s.ToString(),
 443                           file_name_);
 444   io_tracer_->WriteIOOp(io_record, dbg);
 445   return s;
 446 }
 447
 448 uint64_t FSWritableFileTracingWrapper::GetFileSize(const IOOptions& options,
 449                                                    IODebugContext* dbg) {
 450   StopWatchNano timer(clock_);
 451   timer.Start();
 452   uint64_t file_size = target()->GetFileSize(options, dbg);
 453   uint64_t elapsed = timer.ElapsedNanos();
 454   uint64_t io_op_data = 0;
 455   io_op_data |= (1 << IOTraceOp::kIOFileSize);
 456   IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer, io_op_data,
 457                           __func__, elapsed, "OK", file_name_, file_size);
 458   io_tracer_->WriteIOOp(io_record, dbg);
 459   return file_size;
 460 }
 461
 462 IOStatus FSWritableFileTracingWrapper::InvalidateCache(size_t offset,
 463                                                        size_t length) {
 464   StopWatchNano timer(clock_);
 465   timer.Start();
 466   IOStatus s = target()->InvalidateCache(offset, length);
 467   uint64_t elapsed = timer.ElapsedNanos();
 468   uint64_t io_op_data = 0;
 469   io_op_data |= (1 << IOTraceOp::kIOLen);
 470   io_op_data |= (1 << IOTraceOp::kIOOffset);
 471   IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer, io_op_data,
 472                           __func__, elapsed, s.ToString(), file_name_, length,
 473                           static_cast<uint64_t>(offset));
 474   io_tracer_->WriteIOOp(io_record, nullptr /*dbg*/);
 475   return s;
 476 }
 477
 478 IOStatus FSRandomRWFileTracingWrapper::Write(uint64_t offset, const Slice& data,
 479                                              const IOOptions& options,
 480                                              IODebugContext* dbg) {
 481   StopWatchNano timer(clock_);
 482   timer.Start();
 483   IOStatus s = target()->Write(offset, data, options, dbg);
 484   uint64_t elapsed = timer.ElapsedNanos();
 485   uint64_t io_op_data = 0;
 486   io_op_data |= (1 << IOTraceOp::kIOLen);
 487   io_op_data |= (1 << IOTraceOp::kIOOffset);
 488   IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer, io_op_data,
 489                           __func__, elapsed, s.ToString(), file_name_,
 490                           data.size(), offset);
 491   io_tracer_->WriteIOOp(io_record, dbg);
 492   return s;
 493 }
 494
 495 IOStatus FSRandomRWFileTracingWrapper::Read(uint64_t offset, size_t n,
 496                                             const IOOptions& options,
 497                                             Slice* result, char* scratch,
 498                                             IODebugContext* dbg) const {
 499   StopWatchNano timer(clock_);
 500   timer.Start();
 501   IOStatus s = target()->Read(offset, n, options, result, scratch, dbg);
 502   uint64_t elapsed = timer.ElapsedNanos();
 503   uint64_t io_op_data = 0;
 504   io_op_data |= (1 << IOTraceOp::kIOLen);
 505   io_op_data |= (1 << IOTraceOp::kIOOffset);
 506   IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer, io_op_data,
 507                           __func__, elapsed, s.ToString(), file_name_, n,
 508                           offset);
 509   io_tracer_->WriteIOOp(io_record, dbg);
 510   return s;
 511 }
 512
 513 IOStatus FSRandomRWFileTracingWrapper::Flush(const IOOptions& options,
 514                                              IODebugContext* dbg) {
 515   StopWatchNano timer(clock_);
 516   timer.Start();
 517   IOStatus s = target()->Flush(options, dbg);
 518   uint64_t elapsed = timer.ElapsedNanos();
 519   IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer,
 520                           0 /*io_op_data*/, __func__, elapsed, s.ToString(),
 521                           file_name_);
 522   io_tracer_->WriteIOOp(io_record, dbg);
 523   return s;
 524 }
 525
 526 IOStatus FSRandomRWFileTracingWrapper::Close(const IOOptions& options,
 527                                              IODebugContext* dbg) {
 528   StopWatchNano timer(clock_);
 529   timer.Start();
 530   IOStatus s = target()->Close(options, dbg);
 531   uint64_t elapsed = timer.ElapsedNanos();
 532   IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer,
 533                           0 /*io_op_data*/, __func__, elapsed, s.ToString(),
 534                           file_name_);
 535   io_tracer_->WriteIOOp(io_record, dbg);
 536   return s;
 537 }
 538
 539 IOStatus FSRandomRWFileTracingWrapper::Sync(const IOOptions& options,
 540                                             IODebugContext* dbg) {
 541   StopWatchNano timer(clock_);
 542   timer.Start();
 543   IOStatus s = target()->Sync(options, dbg);
 544   uint64_t elapsed = timer.ElapsedNanos();
 545   IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer,
 546                           0 /*io_op_data*/, __func__, elapsed, s.ToString(),
 547                           file_name_);
 548   io_tracer_->WriteIOOp(io_record, dbg);
 549   return s;
 550 }
 551
 552 IOStatus FSRandomRWFileTracingWrapper::Fsync(const IOOptions& options,
 553                                              IODebugContext* dbg) {
 554   StopWatchNano timer(clock_);
 555   timer.Start();
 556   IOStatus s = target()->Fsync(options, dbg);
 557   uint64_t elapsed = timer.ElapsedNanos();
 558   IOTraceRecord io_record(clock_->NowNanos(), TraceType::kIOTracer,
 559                           0 /*io_op_data*/, __func__, elapsed, s.ToString(),
 560                           file_name_);
 561   io_tracer_->WriteIOOp(io_record, dbg);
 562   return s;
 563 }
 564 }  // namespace ROCKSDB_NAMESPACE