Inside Bitcoin

501};
502
503class PosixEnv : public Env {
504 public:
505  PosixEnv();
506  ~PosixEnv() override {
507    static const char msg[] =
508        "PosixEnv singleton destroyed. Unsupported behavior!\n";
509    std::fwrite(msg, 1, sizeof(msg), stderr);
510    std::abort();
511  }
512
513  Status NewSequentialFile(const std::string& filename,
514                           SequentialFile** result) override {
515    int fd = ::open(filename.c_str(), O_RDONLY | kOpenBaseFlags);
516    if (fd < 0) {
517      *result = nullptr;
518      return PosixError(filename, errno);
519    }
520
521    *result = new PosixSequentialFile(filename, fd);
522    return Status::OK();
523  }
524
525  Status NewRandomAccessFile(const std::string& filename,
526                             RandomAccessFile** result) override {
527    *result = nullptr;
528    int fd = ::open(filename.c_str(), O_RDONLY | kOpenBaseFlags);
529    if (fd < 0) {
530      return PosixError(filename, errno);
531    }
532
533    if (!mmap_limiter_.Acquire()) {
534      *result = new PosixRandomAccessFile(filename, fd, &fd_limiter_);
535      return Status::OK();
536    }
537
538    uint64_t file_size;
539    Status status = GetFileSize(filename, &file_size);
540    if (status.ok()) {
541      void* mmap_base =
542          ::mmap(/*addr=*/nullptr, file_size, PROT_READ, MAP_SHARED, fd, 0);
543      if (mmap_base != MAP_FAILED) {
544        *result = new PosixMmapReadableFile(filename,
545                                            reinterpret_cast<char*>(mmap_base),
546                                            file_size, &mmap_limiter_);
547      } else {
548        status = PosixError(filename, errno);
549      }
550    }
551    ::close(fd);
552    if (!status.ok()) {
553      mmap_limiter_.Release();
554    }
555    return status;
556  }
557
558  Status NewWritableFile(const std::string& filename,
559                         WritableFile** result) override {
560    int fd = ::open(filename.c_str(),
561                    O_TRUNC | O_WRONLY | O_CREAT | kOpenBaseFlags, 0644);
562    if (fd < 0) {
563      *result = nullptr;
564      return PosixError(filename, errno);
565    }
566
567    *result = new PosixWritableFile(filename, fd);
568    return Status::OK();
569  }
570
571  Status NewAppendableFile(const std::string& filename,
572                           WritableFile** result) override {
573    int fd = ::open(filename.c_str(),
574                    O_APPEND | O_WRONLY | O_CREAT | kOpenBaseFlags, 0644);
575    if (fd < 0) {
576      *result = nullptr;
577      return PosixError(filename, errno);
578    }
579
580    *result = new PosixWritableFile(filename, fd);
581    return Status::OK();
582  }
583
584  bool FileExists(const std::string& filename) override {
585    return ::access(filename.c_str(), F_OK) == 0;
586  }
587
588  Status GetChildren(const std::string& directory_path,
589                     std::vector<std::string>* result) override {
590    result->clear();
591    ::DIR* dir = ::opendir(directory_path.c_str());
592    if (dir == nullptr) {
593      return PosixError(directory_path, errno);
594    }
595    struct ::dirent* entry;
596    while ((entry = ::readdir(dir)) != nullptr) {
597      result->emplace_back(entry->d_name);
598    }
599    ::closedir(dir);
600    return Status::OK();
601  }
602
603  Status DeleteFile(const std::string& filename) override {
604    if (::unlink(filename.c_str()) != 0) {
605      return PosixError(filename, errno);
606    }
607    return Status::OK();
608  }
609
610  Status CreateDir(const std::string& dirname) override {
611    if (::mkdir(dirname.c_str(), 0755) != 0) {
612      return PosixError(dirname, errno);
613    }
614    return Status::OK();
615  }
616
617  Status DeleteDir(const std::string& dirname) override {
618    if (::rmdir(dirname.c_str()) != 0) {
619      return PosixError(dirname, errno);
620    }
621    return Status::OK();
622  }
623
624  Status GetFileSize(const std::string& filename, uint64_t* size) override {
625    struct ::stat file_stat;
626    if (::stat(filename.c_str(), &file_stat) != 0) {
627      *size = 0;
628      return PosixError(filename, errno);
629    }
630    *size = file_stat.st_size;
631    return Status::OK();
632  }
633
634  Status RenameFile(const std::string& from, const std::string& to) override {
635    if (std::rename(from.c_str(), to.c_str()) != 0) {
636      return PosixError(from, errno);
637    }
638    return Status::OK();
639  }
640
641  Status LockFile(const std::string& filename, FileLock** lock) override {
642    *lock = nullptr;
643
644    int fd = ::open(filename.c_str(), O_RDWR | O_CREAT | kOpenBaseFlags, 0644);
645    if (fd < 0) {
646      return PosixError(filename, errno);
647    }
648
649    if (!locks_.Insert(filename)) {
650      ::close(fd);
651      return Status::IOError("lock " + filename, "already held by process");
652    }
653
654    if (LockOrUnlock(fd, true) == -1) {
655      int lock_errno = errno;
656      ::close(fd);
657      locks_.Remove(filename);
658      return PosixError("lock " + filename, lock_errno);
659    }
660
661    *lock = new PosixFileLock(fd, filename);
662    return Status::OK();
663  }
664
665  Status UnlockFile(FileLock* lock) override {
666    PosixFileLock* posix_file_lock = static_cast<PosixFileLock*>(lock);
667    if (LockOrUnlock(posix_file_lock->fd(), false) == -1) {
668      return PosixError("unlock " + posix_file_lock->filename(), errno);
669    }
670    locks_.Remove(posix_file_lock->filename());
671    ::close(posix_file_lock->fd());
672    delete posix_file_lock;
673    return Status::OK();
674  }
675
676  void Schedule(void (*background_work_function)(void* background_work_arg),
677                void* background_work_arg) override;
678
679  void StartThread(void (*thread_main)(void* thread_main_arg),
680                   void* thread_main_arg) override {
681    std::thread new_thread(thread_main, thread_main_arg);
682    new_thread.detach();
683  }
684
685  Status GetTestDirectory(std::string* result) override {
686    const char* env = std::getenv("TEST_TMPDIR");
687    if (env && env[0] != '\0') {
688      *result = env;
689    } else {
690      char buf[100];
691      std::snprintf(buf, sizeof(buf), "/tmp/leveldbtest-%d",
692                    static_cast<int>(::geteuid()));
693      *result = buf;
694    }
695
696    // The CreateDir status is ignored because the directory may already exist.
697    CreateDir(*result);
698
699    return Status::OK();
700  }
701
702  Status NewLogger(const std::string& filename, Logger** result) override {
703    int fd = ::open(filename.c_str(),
704                    O_APPEND | O_WRONLY | O_CREAT | kOpenBaseFlags, 0644);
705    if (fd < 0) {
706      *result = nullptr;
707      return PosixError(filename, errno);
708    }
709
710    std::FILE* fp = ::fdopen(fd, "w");
711    if (fp == nullptr) {
712      ::close(fd);
713      *result = nullptr;
714      return PosixError(filename, errno);
715    } else {
716      *result = new PosixLogger(fp);
717      return Status::OK();
718    }
719  }
720
721  uint64_t NowMicros() override {
722    static constexpr uint64_t kUsecondsPerSecond = 1000000;
723    struct ::timeval tv;
724    ::gettimeofday(&tv, nullptr);
725    return static_cast<uint64_t>(tv.tv_sec) * kUsecondsPerSecond + tv.tv_usec;
726  }
727
728  void SleepForMicroseconds(int micros) override {
729    std::this_thread::sleep_for(std::chrono::microseconds(micros));
730  }
731
732 private:
733  [[noreturn]] void BackgroundThreadMain();
734
735  [[noreturn]] static void BackgroundThreadEntryPoint(PosixEnv* env) {
736    env->BackgroundThreadMain();
737  }
738
739  // Stores the work item data in a Schedule() call.
740  //
741  // Instances are constructed on the thread calling Schedule() and used on the
742  // background thread.
743  //
744  // This structure is thread-safe because it is immutable.
745  struct BackgroundWorkItem {
746    explicit BackgroundWorkItem(void (*function)(void* arg), void* arg)
747        : function(function), arg(arg) {}
748
749    void (*const function)(void*);
750    void* const arg;