[sql] Histograms for I/O calls seen by browser VFS.

sql/vfs_wrapper.cc

 // Copyright (c) 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "sql/vfs_wrapper.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/debug/leak_annotations.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/strings/string_piece.h"
 
 #if defined(OS_MACOSX) && !defined(OS_IOS)
 #include <CoreFoundation/CoreFoundation.h>
 #include <CoreServices/CoreServices.h>
 
 #include "base/mac/mac_util.h"
 #include "base/mac/scoped_cftyperef.h"
 #endif
 
 namespace sql {
 namespace {
 
 // https://www.sqlite.org/vfs.html - documents the overall VFS system.
 //
 // https://www.sqlite.org/c3ref/vfs.html - VFS methods.  This code tucks the
 // wrapped VFS pointer into the wrapper's pAppData pointer.
 //
 // https://www.sqlite.org/c3ref/file.html - instance of an open file.  This code
 // allocates a VfsFile for this, which contains a pointer to the wrapped file.
 // Idiomatic SQLite would take the wrapped VFS szOsFile and increase it to store
 // additional data as a prefix.
 
+// This enum must match the numbering from Sqlite.VfsEvents in histograms.xml.
+// Do not reorder or remove items, only add new items before VFS_EVENT_MAX.
+enum VfsEventType {
+  // VFS method xOpen() call.
+  VFS_OPEN = 0,
+
+  // VFS method xDelete() call.
+  VFS_DELETE,
+
+  // VFS method xAccess() call.
+  VFS_ACCESS,
+
+  // VFS method xFullPathname() call.
+  VFS_FULLPATHNAME,
+
+  // I/O method xClose() call, should balance VFS_OPEN.
+  VFS_IO_CLOSE,
+
+  // I/O method xRead() call.
+  VFS_IO_READ,
+
+  // I/O method xWrite() call.
+  VFS_IO_WRITE,
+
+  // I/O method xTruncate() call.
+  VFS_IO_TRUNCATE,
+
+  // I/O method xSync() call.
+  VFS_IO_SYNC,
+
+  // I/O method xFileSize() call.
+  VFS_IO_FILESIZE,
+
+  // I/O method xFetch() call.  This is like xRead(), but when using
+  // memory-mapping.
+  VFS_IO_FETCH,
+
+  // Add new items before this one, always keep this one at the end.
+  VFS_EVENT_MAX
+};
+
+// TODO(shess): If the VFS was parameterized, then results could be binned by
+// database.  It would require a separate VFS per database, though the variants
+// could all use the same VFS functions.
+void RecordVfsEvent(VfsEventType vfs_event) {
+  UMA_HISTOGRAM_ENUMERATION("Sqlite.Vfs_Events", vfs_event, VFS_EVENT_MAX);
+}
+
 sqlite3_vfs* GetWrappedVfs(sqlite3_vfs* wrapped_vfs) {
   return static_cast<sqlite3_vfs*>(wrapped_vfs->pAppData);
 }
 
 // NOTE(shess): This structure is allocated by SQLite using malloc.  Do not add
 // C++ objects, they will not be correctly constructed and destructed.  Instead,
 // manually manage a pointer to a C++ object in Open() and Close().
 struct VfsFile {
   const sqlite3_io_methods* methods;
   sqlite3_file* wrapped_file;
 };
 
 VfsFile* AsVfsFile(sqlite3_file* wrapper_file) {
   return reinterpret_cast<VfsFile*>(wrapper_file);
 }
 
 sqlite3_file* GetWrappedFile(sqlite3_file* wrapper_file) {
   return AsVfsFile(wrapper_file)->wrapped_file;
 }
 
 int Close(sqlite3_file* sqlite_file)
 {
+  RecordVfsEvent(VFS_IO_CLOSE);
+
   VfsFile* file = AsVfsFile(sqlite_file);
 
   int r = file->wrapped_file->pMethods->xClose(file->wrapped_file);
   sqlite3_free(file->wrapped_file);
   memset(file, '\0', sizeof(*file));
   return r;
 }
 
 int Read(sqlite3_file* sqlite_file, void* buf, int amt, sqlite3_int64 ofs)
 {
+  RecordVfsEvent(VFS_IO_READ);
+  UMA_HISTOGRAM_COUNTS("Sqlite.Vfs_Read", amt);
+
   sqlite3_file* wrapped_file = GetWrappedFile(sqlite_file);
   return wrapped_file->pMethods->xRead(wrapped_file, buf, amt, ofs);
 }
 
 int Write(sqlite3_file* sqlite_file, const void* buf, int amt,
           sqlite3_int64 ofs)
 {
+  RecordVfsEvent(VFS_IO_WRITE);
+  UMA_HISTOGRAM_COUNTS("Sqlite.Vfs_Write", amt);
+
   sqlite3_file* wrapped_file = GetWrappedFile(sqlite_file);
   return wrapped_file->pMethods->xWrite(wrapped_file, buf, amt, ofs);
 }
 
 int Truncate(sqlite3_file* sqlite_file, sqlite3_int64 size)
 {
+  RecordVfsEvent(VFS_IO_TRUNCATE);
+
   sqlite3_file* wrapped_file = GetWrappedFile(sqlite_file);
   return wrapped_file->pMethods->xTruncate(wrapped_file, size);
 }
 
 int Sync(sqlite3_file* sqlite_file, int flags)
 {
+  RecordVfsEvent(VFS_IO_SYNC);
+
   sqlite3_file* wrapped_file = GetWrappedFile(sqlite_file);
   return wrapped_file->pMethods->xSync(wrapped_file, flags);
 }
 
 int FileSize(sqlite3_file* sqlite_file, sqlite3_int64* size)
 {
+  RecordVfsEvent(VFS_IO_FILESIZE);
+
   sqlite3_file* wrapped_file = GetWrappedFile(sqlite_file);
   return wrapped_file->pMethods->xFileSize(wrapped_file, size);
 }
 
 int Lock(sqlite3_file* sqlite_file, int file_lock)
 {
   sqlite3_file* wrapped_file = GetWrappedFile(sqlite_file);
   return wrapped_file->pMethods->xLock(wrapped_file, file_lock);
 }
 
@@ skipping 43 matching lines @@
   sqlite3_file* wrapped_file = GetWrappedFile(sqlite_file);
   wrapped_file->pMethods->xShmBarrier(wrapped_file);
 }
 
 int ShmUnmap(sqlite3_file *sqlite_file, int del) {
   sqlite3_file* wrapped_file = GetWrappedFile(sqlite_file);
   return wrapped_file->pMethods->xShmUnmap(wrapped_file, del);
 }
 
 int Fetch(sqlite3_file *sqlite_file, sqlite3_int64 off, int amt, void **pp) {
+  RecordVfsEvent(VFS_IO_FETCH);
+  UMA_HISTOGRAM_COUNTS("Sqlite.Vfs_Fetch", amt);
+
   sqlite3_file* wrapped_file = GetWrappedFile(sqlite_file);
   return wrapped_file->pMethods->xFetch(wrapped_file, off, amt, pp);
 }
 
 int Unfetch(sqlite3_file *sqlite_file, sqlite3_int64 off, void *p) {
   sqlite3_file* wrapped_file = GetWrappedFile(sqlite_file);
   return wrapped_file->pMethods->xUnfetch(wrapped_file, off, p);
 }
 
 #if defined(OS_MACOSX) && !defined(OS_IOS)
 // Helper to convert a POSIX path into a CoreFoundation path.
 base::ScopedCFTypeRef<CFURLRef> CFURLRefForPath(const char* path){
   base::ScopedCFTypeRef<CFStringRef> urlString(
       CFStringCreateWithFileSystemRepresentation(kCFAllocatorDefault, path));
   base::ScopedCFTypeRef<CFURLRef> url(
       CFURLCreateWithFileSystemPath(kCFAllocatorDefault, urlString,
                                     kCFURLPOSIXPathStyle, FALSE));
   return url;
 }
 #endif
 
 int Open(sqlite3_vfs* vfs, const char* file_name, sqlite3_file* wrapper_file,
          int desired_flags, int* used_flags) {
+  RecordVfsEvent(VFS_OPEN);
+
   sqlite3_vfs* wrapped_vfs = GetWrappedVfs(vfs);
 
   sqlite3_file* wrapped_file = static_cast<sqlite3_file*>(
       sqlite3_malloc(wrapped_vfs->szOsFile));
   if (!wrapped_file)
     return SQLITE_NOMEM;
 
   // NOTE(shess): SQLite's unixOpen() makes assumptions about the structure of
   // |file_name|.  Do not pass a local copy, here, only the passed-in value.
   int rc = wrapped_vfs->xOpen(wrapped_vfs,
@@ skipping 101 matching lines @@
       // Methods above are valid for version 2.
       Fetch,
       Unfetch,
     };
     file->methods = &io_methods;
   }
   return SQLITE_OK;
 }
 
 int Delete(sqlite3_vfs* vfs, const char* file_name, int sync_dir) {
+  RecordVfsEvent(VFS_DELETE);
+
   sqlite3_vfs* wrapped_vfs = GetWrappedVfs(vfs);
   return wrapped_vfs->xDelete(wrapped_vfs, file_name, sync_dir);
 }
 
 int Access(sqlite3_vfs* vfs, const char* file_name, int flag, int* res) {
+  RecordVfsEvent(VFS_ACCESS);
+
   sqlite3_vfs* wrapped_vfs = GetWrappedVfs(vfs);
   return wrapped_vfs->xAccess(wrapped_vfs, file_name, flag, res);
 }
 
 int FullPathname(sqlite3_vfs* vfs, const char* relative_path,
                  int buf_size, char* absolute_path) {
+  RecordVfsEvent(VFS_FULLPATHNAME);
+
   sqlite3_vfs* wrapped_vfs = GetWrappedVfs(vfs);
   return wrapped_vfs->xFullPathname(
       wrapped_vfs, relative_path, buf_size, absolute_path);
 }
 
 void* DlOpen(sqlite3_vfs* vfs, const char* filename) {
   sqlite3_vfs* wrapped_vfs = GetWrappedVfs(vfs);
   return wrapped_vfs->xDlOpen(wrapped_vfs, filename);
 }
 
@@ skipping 116 matching lines @@
 
   if (SQLITE_OK == sqlite3_vfs_register(wrapper_vfs.get(), 0)) {
     ANNOTATE_LEAKING_OBJECT_PTR(wrapper_vfs.get());
     wrapper_vfs.release();
   }
 
   return sqlite3_vfs_find(kVFSName);
 }
 
 }  // namespace sql