leveldb::anonymous_namespace{env_posix.cc}::PosixEnv Class Reference

Inheritance diagram for leveldb::anonymous_namespace{env_posix.cc}::PosixEnv:

Collaboration diagram for leveldb::anonymous_namespace{env_posix.cc}::PosixEnv:

Classes
struct	BGItem

Public Member Functions
	PosixEnv ()
virtual	~PosixEnv ()
virtual Status	NewSequentialFile (const std::string &fname, SequentialFile **result)
virtual Status	NewRandomAccessFile (const std::string &fname, RandomAccessFile **result)
virtual Status	NewWritableFile (const std::string &fname, WritableFile **result)
virtual Status	NewAppendableFile (const std::string &fname, WritableFile **result)
virtual bool	FileExists (const std::string &fname)
virtual Status	GetChildren (const std::string &dir, std::vector< std::string > *result)
virtual Status	DeleteFile (const std::string &fname)
virtual Status	CreateDir (const std::string &name)
virtual Status	DeleteDir (const std::string &name)
virtual Status	GetFileSize (const std::string &fname, uint64_t *size)
virtual Status	RenameFile (const std::string &src, const std::string &target)
virtual Status	LockFile (const std::string &fname, FileLock **lock)
virtual Status	UnlockFile (FileLock *lock)
virtual void	Schedule (void(*function)(void *), void *arg)
virtual void	StartThread (void(*function)(void *arg), void *arg)
virtual Status	GetTestDirectory (std::string *result)
virtual Status	NewLogger (const std::string &fname, Logger **result)
virtual uint64_t	NowMicros ()
virtual void	SleepForMicroseconds (int micros)
Public Member Functions inherited from leveldb::Env
	Env ()
virtual	~Env ()
virtual void	Schedule (void(*function)(void *arg), void *arg)=0

Static Public Member Functions
static uint64_t	gettid ()
Static Public Member Functions inherited from leveldb::Env
static Env *	Default ()

Private Types
typedef std::deque< BGItem >	BGQueue

Private Member Functions
void	PthreadCall (const char *label, int result)
void	BGThread ()

Static Private Member Functions
static void *	BGThreadWrapper (void *arg)

Private Attributes
pthread_mutex_t	mu_
pthread_cond_t	bgsignal_
pthread_t	bgthread_
bool	started_bgthread_
BGQueue	queue_
PosixLockTable	locks_
MmapLimiter	mmap_limit_

Detailed Description

Definition at line 291 of file env_posix.cc.

Member Typedef Documentation

BGQueue

typedef std::deque<BGItem> leveldb::anonymous_namespace{env_posix.cc}::PosixEnv::BGQueue

private

Definition at line 531 of file env_posix.cc.

Constructor & Destructor Documentation

PosixEnv()

leveldb::anonymous_namespace{env_posix.cc}::PosixEnv::PosixEnv

(

)

Definition at line 538 of file env_posix.cc.

                   : started_bgthread_(false) {
  PthreadCall("mutex_init", pthread_mutex_init(&mu_, NULL));
  PthreadCall("cvar_init", pthread_cond_init(&bgsignal_, NULL));
}

Here is the call graph for this function:

Here is the caller graph for this function:

~PosixEnv()

virtual leveldb::anonymous_namespace{env_posix.cc}::PosixEnv::~PosixEnv ( )

inlinevirtual

Definition at line 294 of file env_posix.cc.

                      {
    char msg[] = "Destroying Env::Default()\n";
    fwrite(msg, 1, sizeof(msg), stderr);
    abort();
  }

Member Function Documentation

BGThread()

void leveldb::anonymous_namespace{env_posix.cc}::PosixEnv::BGThread ( )

private

Definition at line 568 of file env_posix.cc.

                        {
  while (true) {
    // Wait until there is an item that is ready to run
    PthreadCall("lock", pthread_mutex_lock(&mu_));
    while (queue_.empty()) {
      PthreadCall("wait", pthread_cond_wait(&bgsignal_, &mu_));
    }

    void (*function)(void*) = queue_.front().function;
    void* arg = queue_.front().arg;
    queue_.pop_front();

    PthreadCall("unlock", pthread_mutex_unlock(&mu_));
    (*function)(arg);
  }
}

Here is the call graph for this function:

BGThreadWrapper()

static void* leveldb::anonymous_namespace{env_posix.cc}::PosixEnv::BGThreadWrapper ( void *  arg )

inlinestaticprivate

Definition at line 519 of file env_posix.cc.

                                          {
    reinterpret_cast<PosixEnv*>(arg)->BGThread();
    return NULL;
  }

Here is the caller graph for this function:

CreateDir()

virtual Status leveldb::anonymous_namespace{env_posix.cc}::PosixEnv::CreateDir ( const std::string &  name )

inlinevirtual

Implements leveldb::Env.

Definition at line 393 of file env_posix.cc.

                                                  {
    Status result;
    if (mkdir(name.c_str(), 0755) != 0) {
      result = IOError(name, errno);
    }
    return result;
  }

Here is the call graph for this function:

DeleteDir()

virtual Status leveldb::anonymous_namespace{env_posix.cc}::PosixEnv::DeleteDir ( const std::string &  name )

inlinevirtual

Implements leveldb::Env.

Definition at line 401 of file env_posix.cc.

                                                  {
    Status result;
    if (rmdir(name.c_str()) != 0) {
      result = IOError(name, errno);
    }
    return result;
  }

Here is the call graph for this function:

DeleteFile()

virtual Status leveldb::anonymous_namespace{env_posix.cc}::PosixEnv::DeleteFile ( const std::string &  fname )

inlinevirtual

Implements leveldb::Env.

Definition at line 385 of file env_posix.cc.

                                                    {
    Status result;
    if (unlink(fname.c_str()) != 0) {
      result = IOError(fname, errno);
    }
    return result;
  }

Here is the call graph for this function:

FileExists()

virtual bool leveldb::anonymous_namespace{env_posix.cc}::PosixEnv::FileExists ( const std::string &  fname )

inlinevirtual

Implements leveldb::Env.

Definition at line 366 of file env_posix.cc.

                                                  {
    return access(fname.c_str(), F_OK) == 0;
  }

GetChildren()

virtual Status leveldb::anonymous_namespace{env_posix.cc}::PosixEnv::GetChildren ( const std::string &  dir, std::vector< std::string > *  result  )

inlinevirtual

Implements leveldb::Env.

Definition at line 370 of file env_posix.cc.

                                                           {
    result->clear();
    DIR* d = opendir(dir.c_str());
    if (d == NULL) {
      return IOError(dir, errno);
    }
    struct dirent* entry;
    while ((entry = readdir(d)) != NULL) {
      result->push_back(entry->d_name);
    }
    closedir(d);
    return Status::OK();
  }

Here is the call graph for this function:

GetFileSize()

virtual Status leveldb::anonymous_namespace{env_posix.cc}::PosixEnv::GetFileSize ( const std::string &  fname, uint64_t *  size  )

inlinevirtual

Implements leveldb::Env.

Definition at line 409 of file env_posix.cc.

                                                                     {
    Status s;
    struct stat sbuf;
    if (stat(fname.c_str(), &sbuf) != 0) {
      *size = 0;
      s = IOError(fname, errno);
    } else {
      *size = sbuf.st_size;
    }
    return s;
  }

Here is the call graph for this function:

GetTestDirectory()

virtual Status leveldb::anonymous_namespace{env_posix.cc}::PosixEnv::GetTestDirectory ( std::string *  result )

inlinevirtual

Implements leveldb::Env.

Definition at line 467 of file env_posix.cc.

                                                     {
    const char* env = getenv("TEST_TMPDIR");
    if (env && env[0] != '\0') {
      *result = env;
    } else {
      char buf[100];
      snprintf(buf, sizeof(buf), "/tmp/leveldbtest-%d", int(geteuid()));
      *result = buf;
    }
    // Directory may already exist
    CreateDir(*result);
    return Status::OK();
  }

Here is the call graph for this function:

gettid()

static uint64_t leveldb::anonymous_namespace{env_posix.cc}::PosixEnv::gettid ( )

inlinestatic

Definition at line 481 of file env_posix.cc.

                           {
    pthread_t tid = pthread_self();
    uint64_t thread_id = 0;
    memcpy(&thread_id, &tid, std::min(sizeof(thread_id), sizeof(tid)));
    return thread_id;
  }

LockFile()

virtual Status leveldb::anonymous_namespace{env_posix.cc}::PosixEnv::LockFile ( const std::string &  fname, FileLock **  lock  )

inlinevirtual

Implements leveldb::Env.

Definition at line 429 of file env_posix.cc.

                                                                   {
    *lock = NULL;
    Status result;
    int fd = open(fname.c_str(), O_RDWR | O_CREAT, 0644);
    if (fd < 0) {
      result = IOError(fname, errno);
    } else if (!locks_.Insert(fname)) {
      close(fd);
      result = Status::IOError("lock " + fname, "already held by process");
    } else if (LockOrUnlock(fd, true) == -1) {
      result = IOError("lock " + fname, errno);
      close(fd);
      locks_.Remove(fname);
    } else {
      PosixFileLock* my_lock = new PosixFileLock;
      my_lock->fd_ = fd;
      my_lock->name_ = fname;
      *lock = my_lock;
    }
    return result;
  }

Here is the call graph for this function:

NewAppendableFile()

virtual Status leveldb::anonymous_namespace{env_posix.cc}::PosixEnv::NewAppendableFile ( const std::string &  fname, WritableFile **  result  )

inlinevirtual

Reimplemented from leveldb::Env.

Definition at line 353 of file env_posix.cc.

                                                          {
    Status s;
    FILE* f = fopen(fname.c_str(), "a");
    if (f == NULL) {
      *result = NULL;
      s = IOError(fname, errno);
    } else {
      *result = new PosixWritableFile(fname, f);
    }
    return s;
  }

Here is the call graph for this function:

NewLogger()

virtual Status leveldb::anonymous_namespace{env_posix.cc}::PosixEnv::NewLogger ( const std::string &  fname, Logger **  result  )

inlinevirtual

Implements leveldb::Env.

Definition at line 488 of file env_posix.cc.

                                                                    {
    FILE* f = fopen(fname.c_str(), "w");
    if (f == NULL) {
      *result = NULL;
      return IOError(fname, errno);
    } else {
      *result = new PosixLogger(f, &PosixEnv::gettid);
      return Status::OK();
    }
  }

Here is the call graph for this function:

NewRandomAccessFile()

virtual Status leveldb::anonymous_namespace{env_posix.cc}::PosixEnv::NewRandomAccessFile ( const std::string &  fname, RandomAccessFile **  result  )

inlinevirtual

Implements leveldb::Env.

Definition at line 312 of file env_posix.cc.

                                                                {
    *result = NULL;
    Status s;
    int fd = open(fname.c_str(), O_RDONLY);
    if (fd < 0) {
      s = IOError(fname, errno);
    } else if (mmap_limit_.Acquire()) {
      uint64_t size;
      s = GetFileSize(fname, &size);
      if (s.ok()) {
        void* base = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
        if (base != MAP_FAILED) {
          *result = new PosixMmapReadableFile(fname, base, size, &mmap_limit_);
        } else {
          s = IOError(fname, errno);
        }
      }
      close(fd);
      if (!s.ok()) {
        mmap_limit_.Release();
      }
    } else {
      *result = new PosixRandomAccessFile(fname, fd);
    }
    return s;
  }

Here is the call graph for this function:

NewSequentialFile()

virtual Status leveldb::anonymous_namespace{env_posix.cc}::PosixEnv::NewSequentialFile ( const std::string &  fname, SequentialFile **  result  )

inlinevirtual

Implements leveldb::Env.

Definition at line 300 of file env_posix.cc.

                                                            {
    FILE* f = fopen(fname.c_str(), "r");
    if (f == NULL) {
      *result = NULL;
      return IOError(fname, errno);
    } else {
      *result = new PosixSequentialFile(fname, f);
      return Status::OK();
    }
  }

Here is the call graph for this function:

NewWritableFile()

virtual Status leveldb::anonymous_namespace{env_posix.cc}::PosixEnv::NewWritableFile ( const std::string &  fname, WritableFile **  result  )

inlinevirtual

Implements leveldb::Env.

Definition at line 340 of file env_posix.cc.

                                                        {
    Status s;
    FILE* f = fopen(fname.c_str(), "w");
    if (f == NULL) {
      *result = NULL;
      s = IOError(fname, errno);
    } else {
      *result = new PosixWritableFile(fname, f);
    }
    return s;
  }

Here is the call graph for this function:

NowMicros()

virtual uint64_t leveldb::anonymous_namespace{env_posix.cc}::PosixEnv::NowMicros ( )

inlinevirtual

Implements leveldb::Env.

Definition at line 499 of file env_posix.cc.

                               {
    struct timeval tv;
    gettimeofday(&tv, NULL);
    return static_cast<uint64_t>(tv.tv_sec) * 1000000 + tv.tv_usec;
  }

PthreadCall()

void leveldb::anonymous_namespace{env_posix.cc}::PosixEnv::PthreadCall ( const char *  label, int  result  )

inlineprivate

Definition at line 510 of file env_posix.cc.

                                                  {
    if (result != 0) {
      fprintf(stderr, "pthread %s: %s\n", label, strerror(result));
      abort();
    }
  }

Here is the caller graph for this function:

RenameFile()

virtual Status leveldb::anonymous_namespace{env_posix.cc}::PosixEnv::RenameFile ( const std::string &  src, const std::string &  target  )

inlinevirtual

Implements leveldb::Env.

Definition at line 421 of file env_posix.cc.

                                                                           {
    Status result;
    if (rename(src.c_str(), target.c_str()) != 0) {
      result = IOError(src, errno);
    }
    return result;
  }

Here is the call graph for this function:

Schedule()

void leveldb::anonymous_namespace{env_posix.cc}::PosixEnv::Schedule ( void(*)(void *)  function, void *  arg  )

virtual

Definition at line 543 of file env_posix.cc.

                                                          {
  PthreadCall("lock", pthread_mutex_lock(&mu_));

  // Start background thread if necessary
  if (!started_bgthread_) {
    started_bgthread_ = true;
    PthreadCall(
        "create thread",
        pthread_create(&bgthread_, NULL,  &PosixEnv::BGThreadWrapper, this));
  }

  // If the queue is currently empty, the background thread may currently be
  // waiting.
  if (queue_.empty()) {
    PthreadCall("signal", pthread_cond_signal(&bgsignal_));
  }

  // Add to priority queue
  queue_.push_back(BGItem());
  queue_.back().function = function;
  queue_.back().arg = arg;

  PthreadCall("unlock", pthread_mutex_unlock(&mu_));
}

Here is the call graph for this function:

SleepForMicroseconds()

virtual void leveldb::anonymous_namespace{env_posix.cc}::PosixEnv::SleepForMicroseconds ( int  micros )

inlinevirtual

Implements leveldb::Env.

Definition at line 505 of file env_posix.cc.

                                                {
    usleep(micros);
  }

StartThread()

void leveldb::anonymous_namespace{env_posix.cc}::PosixEnv::StartThread ( void(*)(void *arg)  function, void *  arg  )

virtual

Implements leveldb::Env.

Definition at line 598 of file env_posix.cc.

                                                                 {
  pthread_t t;
  StartThreadState* state = new StartThreadState;
  state->user_function = function;
  state->arg = arg;
  PthreadCall("start thread",
              pthread_create(&t, NULL,  &StartThreadWrapper, state));
}

Here is the call graph for this function:

UnlockFile()

virtual Status leveldb::anonymous_namespace{env_posix.cc}::PosixEnv::UnlockFile ( FileLock *  lock )

inlinevirtual

Implements leveldb::Env.

Definition at line 451 of file env_posix.cc.

                                            {
    PosixFileLock* my_lock = reinterpret_cast<PosixFileLock*>(lock);
    Status result;
    if (LockOrUnlock(my_lock->fd_, false) == -1) {
      result = IOError("unlock", errno);
    }
    locks_.Remove(my_lock->name_);
    close(my_lock->fd_);
    delete my_lock;
    return result;
  }

Here is the call graph for this function:

Member Data Documentation

bgsignal_

pthread_cond_t leveldb::anonymous_namespace{env_posix.cc}::PosixEnv::bgsignal_

private

Definition at line 525 of file env_posix.cc.

bgthread_

pthread_t leveldb::anonymous_namespace{env_posix.cc}::PosixEnv::bgthread_

private

Definition at line 526 of file env_posix.cc.

locks_

PosixLockTable leveldb::anonymous_namespace{env_posix.cc}::PosixEnv::locks_

private

Definition at line 534 of file env_posix.cc.

mmap_limit_

MmapLimiter leveldb::anonymous_namespace{env_posix.cc}::PosixEnv::mmap_limit_

private

Definition at line 535 of file env_posix.cc.

mu_

pthread_mutex_t leveldb::anonymous_namespace{env_posix.cc}::PosixEnv::mu_

private

Definition at line 524 of file env_posix.cc.

queue_

BGQueue leveldb::anonymous_namespace{env_posix.cc}::PosixEnv::queue_

private

Definition at line 532 of file env_posix.cc.

started_bgthread_

bool leveldb::anonymous_namespace{env_posix.cc}::PosixEnv::started_bgthread_

private

Definition at line 527 of file env_posix.cc.

---

The documentation for this class was generated from the following file:

• util/env_posix.cc