   }
 
   public func mkdir(dirPath: String, mode: UInt32 = DEFAULT_DIR_MODE) -> Int32 {
-    return retry { _mkdir(dirPath, mode) }
+    return retry { Glibc.mkdir(dirPath, mode) }
   }
 
   public func read(fd: Int32, address: UnsafeMutablePointer<Void>,
       length: Int) -> Int {
-    return retry { _read(fd, address, length) }
+    return retry { Glibc.read(fd, address, length) }
   }
 
   public func write(fd: Int32, address: UnsafePointer<Void>,
       length: Int) -> Int {
-    return retry { _write(fd, address, length) }
+    return retry { Glibc.write(fd, address, length) }
   }
 
   public func writeString(fd: Int32, string: String) -> Int {

  }

  public func readdir(dirp: COpaquePointer) -> DirentEntry {
    return dirp != nil ? _readdir(dirp) : nil
  }

  public func opendir(path: String) -> COpaquePointer {
    return _opendir(path)
  }

  public func opendir(pathBytes: [UInt8]) -> COpaquePointer {
    return _opendir(UnsafePointer<CChar>(pathBytes))
  }

  public func closedir(dirp: COpaquePointer) -> Int32 {
    return retry { _closedir(dirp) }
  }

  public func fgets(buffer: UnsafeMutablePointer<CChar>, length: Int32,
      fp: UnsafeMutablePointer<FILE>) -> UnsafeMutablePointer<CChar> {
    return _fgets(buffer, length, fp)
  }

  public func fread(buffer: UnsafeMutablePointer<Void>, size: Int,
      nmemb: Int, fp: UnsafeMutablePointer<FILE>) -> Int {
    return _fread(buffer, size, nmemb, fp)
  }

  public func popen(command: String, operation: PopenOperation = .R)

  }

  public func close(fd: Int32) -> Int32 {
    return retry { Glibc.close(fd) }
  }

  public func fflush(stream: UnsafeMutablePointer<FILE> = nil) -> Int32 {
    return Glibc.fflush(stream)
  }

  public func lseek(fd: Int32, offset: Int, whence: Int32) -> Int {
    return retry { Glibc.lseek(fd, offset, whence) }
  }

  public var pid: Int32 {
    return Glibc.getpid()
  }

  public func rename(oldPath: String, newPath: String) -> Int32 {
    return Glibc.rename(oldPath, newPath)
  }

  public func unlink(path: String) -> Int32 {
    return Glibc.unlink(path)
  }

  public var cwd: String? {
    var a = [CChar](count:256, repeatedValue: 0)
    let i = Glibc.getcwd(&a, 255)
    if i != nil {
      return String.fromCharCodes(a)
    }
