Inside Bitcoin

501    }
502    do {
503      char base_name[_MAX_FNAME];
504      char ext[_MAX_EXT];
505
506      auto find_data_filename = toUtf8(find_data.cFileName);
507      if (!_splitpath_s(find_data_filename.c_str(), nullptr, 0, nullptr, 0,
508                        base_name, ARRAYSIZE(base_name), ext, ARRAYSIZE(ext))) {
509        result->emplace_back(std::string(base_name) + ext);
510      }
511    } while (::FindNextFileW(dir_handle, &find_data));
512    DWORD last_error = ::GetLastError();
513    ::FindClose(dir_handle);
514    if (last_error != ERROR_NO_MORE_FILES) {
515      return WindowsError(directory_path, last_error);
516    }
517    return Status::OK();
518  }
519
520  Status DeleteFile(const std::string& filename) override {
521    auto wFilename = toUtf16(filename);
522    if (!::DeleteFileW(wFilename.c_str())) {
523      return WindowsError(filename, ::GetLastError());
524    }
525    return Status::OK();
526  }
527
528  Status CreateDir(const std::string& dirname) override {
529    auto wDirname = toUtf16(dirname);
530    if (!::CreateDirectoryW(wDirname.c_str(), nullptr)) {
531      return WindowsError(dirname, ::GetLastError());
532    }
533    return Status::OK();
534  }
535
536  Status DeleteDir(const std::string& dirname) override {
537    auto wDirname = toUtf16(dirname);
538    if (!::RemoveDirectoryW(wDirname.c_str())) {
539      return WindowsError(dirname, ::GetLastError());
540    }
541    return Status::OK();
542  }
543
544  Status GetFileSize(const std::string& filename, uint64_t* size) override {
545    WIN32_FILE_ATTRIBUTE_DATA file_attributes;
546    auto wFilename = toUtf16(filename);
547    if (!::GetFileAttributesExW(wFilename.c_str(), GetFileExInfoStandard,
548                                &file_attributes)) {
549      return WindowsError(filename, ::GetLastError());
550    }
551    ULARGE_INTEGER file_size;
552    file_size.HighPart = file_attributes.nFileSizeHigh;
553    file_size.LowPart = file_attributes.nFileSizeLow;
554    *size = file_size.QuadPart;
555    return Status::OK();
556  }
557
558  Status RenameFile(const std::string& from, const std::string& to) override {
559    // Try a simple move first. It will only succeed when |to| doesn't already
560    // exist.
561    auto wFrom = toUtf16(from);
562    auto wTo = toUtf16(to);
563    if (::MoveFileW(wFrom.c_str(), wTo.c_str())) {
564      return Status::OK();
565    }
566    DWORD move_error = ::GetLastError();
567
568    // Try the full-blown replace if the move fails, as ReplaceFile will only
569    // succeed when |to| does exist. When writing to a network share, we may not
570    // be able to change the ACLs. Ignore ACL errors then
571    // (REPLACEFILE_IGNORE_MERGE_ERRORS).
572    if (::ReplaceFileW(wTo.c_str(), wFrom.c_str(), /*lpBackupFileName=*/nullptr,
573                       REPLACEFILE_IGNORE_MERGE_ERRORS,
574                       /*lpExclude=*/nullptr, /*lpReserved=*/nullptr)) {
575      return Status::OK();
576    }
577    DWORD replace_error = ::GetLastError();
578    // In the case of FILE_ERROR_NOT_FOUND from ReplaceFile, it is likely that
579    // |to| does not exist. In this case, the more relevant error comes from the
580    // call to MoveFile.
581    if (replace_error == ERROR_FILE_NOT_FOUND ||
582        replace_error == ERROR_PATH_NOT_FOUND) {
583      return WindowsError(from, move_error);
584    } else {
585      return WindowsError(from, replace_error);
586    }
587  }
588
589  Status LockFile(const std::string& filename, FileLock** lock) override {
590    *lock = nullptr;
591    Status result;
592    auto wFilename = toUtf16(filename);
593    ScopedHandle handle = ::CreateFileW(
594        wFilename.c_str(), GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ,
595        /*lpSecurityAttributes=*/nullptr, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL,
596        nullptr);
597    if (!handle.is_valid()) {
598      result = WindowsError(filename, ::GetLastError());
599    } else if (!LockOrUnlock(handle.get(), true)) {
600      result = WindowsError("lock " + filename, ::GetLastError());
601    } else {
602      *lock = new WindowsFileLock(std::move(handle), filename);
603    }
604    return result;
605  }
606
607  Status UnlockFile(FileLock* lock) override {
608    WindowsFileLock* windows_file_lock =
609        reinterpret_cast<WindowsFileLock*>(lock);
610    if (!LockOrUnlock(windows_file_lock->handle().get(), false)) {
611      return WindowsError("unlock " + windows_file_lock->filename(),
612                          ::GetLastError());
613    }
614    delete windows_file_lock;
615    return Status::OK();
616  }
617
618  void Schedule(void (*background_work_function)(void* background_work_arg),
619                void* background_work_arg) override;
620
621  void StartThread(void (*thread_main)(void* thread_main_arg),
622                   void* thread_main_arg) override {
623    std::thread new_thread(thread_main, thread_main_arg);
624    new_thread.detach();
625  }
626
627  Status GetTestDirectory(std::string* result) override {
628    const char* env = getenv("TEST_TMPDIR");
629    if (env && env[0] != '\0') {
630      *result = env;
631      return Status::OK();
632    }
633
634    wchar_t wtmp_path[MAX_PATH];
635    if (!GetTempPathW(ARRAYSIZE(wtmp_path), wtmp_path)) {
636      return WindowsError("GetTempPath", ::GetLastError());
637    }
638    std::string tmp_path = toUtf8(std::wstring(wtmp_path));
639    std::stringstream ss;
640    ss << tmp_path << "leveldbtest-" << std::this_thread::get_id();
641    *result = ss.str();
642
643    // Directory may already exist
644    CreateDir(*result);
645    return Status::OK();
646  }
647
648  Status NewLogger(const std::string& filename, Logger** result) override {
649    auto wFilename = toUtf16(filename);
650    std::FILE* fp = _wfopen(wFilename.c_str(), L"w");
651    if (fp == nullptr) {
652      *result = nullptr;
653      return WindowsError(filename, ::GetLastError());
654    } else {
655      *result = new WindowsLogger(fp);
656      return Status::OK();
657    }
658  }
659
660  uint64_t NowMicros() override {
661    // GetSystemTimeAsFileTime typically has a resolution of 10-20 msec.
662    // TODO(cmumford): Switch to GetSystemTimePreciseAsFileTime which is
663    // available in Windows 8 and later.
664    FILETIME ft;
665    ::GetSystemTimeAsFileTime(&ft);
666    // Each tick represents a 100-nanosecond intervals since January 1, 1601
667    // (UTC).
668    uint64_t num_ticks =
669        (static_cast<uint64_t>(ft.dwHighDateTime) << 32) + ft.dwLowDateTime;
670    return num_ticks / 10;
671  }
672
673  void SleepForMicroseconds(int micros) override {
674    std::this_thread::sleep_for(std::chrono::microseconds(micros));
675  }
676
677 private:
678  [[noreturn]] void BackgroundThreadMain();
679
680  [[noreturn]] static void BackgroundThreadEntryPoint(WindowsEnv* env) {
681    env->BackgroundThreadMain();
682  }
683
684  // Stores the work item data in a Schedule() call.
685  //
686  // Instances are constructed on the thread calling Schedule() and used on the
687  // background thread.
688  //
689  // This structure is thread-safe because it is immutable.
690  struct BackgroundWorkItem {
691    explicit BackgroundWorkItem(void (*function)(void* arg), void* arg)
692        : function(function), arg(arg) {}
693
694    void (*const function)(void*);
695    void* const arg;
696  };
697
698  port::Mutex background_work_mutex_;
699  port::CondVar background_work_cv_ GUARDED_BY(background_work_mutex_);
700  bool started_background_thread_ GUARDED_BY(background_work_mutex_);
701
702  std::queue<BackgroundWorkItem> background_work_queue_
703      GUARDED_BY(background_work_mutex_);
704
705  Limiter mmap_limiter_;  // Thread-safe.
706
707  // Converts a Windows wide multi-byte UTF-16 string to a UTF-8 string.
708  // See http://utf8everywhere.org/#windows
709  std::string toUtf8(const std::wstring& wstr) {
710    if (wstr.empty()) return std::string();
711    int size_needed = WideCharToMultiByte(
712        CP_UTF8, 0, &wstr[0], (int)wstr.size(), NULL, 0, NULL, NULL);
713    std::string strTo(size_needed, 0);
714    WideCharToMultiByte(CP_UTF8, 0, &wstr[0], (int)wstr.size(), &strTo[0],
715                        size_needed, NULL, NULL);
716    return strTo;
717  }
718
719  // Converts a UTF-8 string to a Windows UTF-16 multi-byte wide character
720  // string.
721  // See http://utf8everywhere.org/#windows
722  std::wstring toUtf16(const std::string& str) {
723    if (str.empty()) return std::wstring();
724    int size_needed =
725        MultiByteToWideChar(CP_UTF8, 0, &str[0], (int)str.size(), NULL, 0);
726    std::wstring strTo(size_needed, 0);
727    MultiByteToWideChar(CP_UTF8, 0, &str[0], (int)str.size(), &strTo[0],
728                        size_needed);
729    return strTo;
730  }
731};
732
733// Return the maximum number of concurrent mmaps.
734int MaxMmaps() { return g_mmap_limit; }
735
736WindowsEnv::WindowsEnv()
737    : background_work_cv_(&background_work_mutex_),
738      started_background_thread_(false),
739      mmap_limiter_(MaxMmaps()) {}
740
741void WindowsEnv::Schedule(
742    void (*background_work_function)(void* background_work_arg),
743    void* background_work_arg) {
744  background_work_mutex_.Lock();
745
746  // Start the background thread, if we haven't done so already.
747  if (!started_background_thread_) {
748    started_background_thread_ = true;
749    std::thread background_thread(WindowsEnv::BackgroundThreadEntryPoint, this);
750    background_thread.detach();