lib/Support/Unix/PathV2.inc

   1 //===- llvm/Support/Unix/PathV2.cpp - Unix Path Implementation --*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the Unix specific implementation of the PathV2 API.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 //===----------------------------------------------------------------------===//
  15 //=== WARNING: Implementation here must contain only generic UNIX code that
  16 //===          is guaranteed to work on *all* UNIX variants.
  17 //===----------------------------------------------------------------------===//
  18
  19 #include "Unix.h"
  20 #include "llvm/Support/Process.h"
  21 #if HAVE_SYS_STAT_H
  22 #include <sys/stat.h>
  23 #endif
  24 #if HAVE_FCNTL_H
  25 #include <fcntl.h>
  26 #endif
  27 #ifdef HAVE_SYS_MMAN_H
  28 #include <sys/mman.h>
  29 #endif
  30 #if HAVE_DIRENT_H
  31 # include <dirent.h>
  32 # define NAMLEN(dirent) strlen((dirent)->d_name)
  33 #else
  34 # define dirent direct
  35 # define NAMLEN(dirent) (dirent)->d_namlen
  36 # if HAVE_SYS_NDIR_H
  37 #  include <sys/ndir.h>
  38 # endif
  39 # if HAVE_SYS_DIR_H
  40 #  include <sys/dir.h>
  41 # endif
  42 # if HAVE_NDIR_H
  43 #  include <ndir.h>
  44 # endif
  45 #endif
  46 #if HAVE_STDIO_H
  47 #include <stdio.h>
  48 #endif
  49 #if HAVE_LIMITS_H
  50 #include <limits.h>
  51 #endif
  52
  53 #ifdef __APPLE__
  54 #include <mach-o/dyld.h>
  55 #endif
  56
  57 // Both stdio.h and cstdio are included via different pathes and
  58 // stdcxx's cstdio doesn't include stdio.h, so it doesn't #undef the macros
  59 // either.
  60 #undef ferror
  61 #undef feof
  62
  63 // For GNU Hurd
  64 #if defined(__GNU__) && !defined(PATH_MAX)
  65 # define PATH_MAX 4096
  66 #endif
  67
  68 using namespace llvm;
  69
  70 namespace {
  71   /// This class automatically closes the given file descriptor when it goes out
  72   /// of scope. You can take back explicit ownership of the file descriptor by
  73   /// calling take(). The destructor does not verify that close was successful.
  74   /// Therefore, never allow this class to call close on a file descriptor that
  75   /// has been read from or written to.
  76   struct AutoFD {
  77     int FileDescriptor;
  78
  79     AutoFD(int fd) : FileDescriptor(fd) {}
  80     ~AutoFD() {
  81       if (FileDescriptor >= 0)
  82         ::close(FileDescriptor);
  83     }
  84
  85     int take() {
  86       int ret = FileDescriptor;
  87       FileDescriptor = -1;
  88       return ret;
  89     }
  90
  91     operator int() const {return FileDescriptor;}
  92   };
  93
  94   error_code TempDir(SmallVectorImpl<char> &result) {
  95     // FIXME: Don't use TMPDIR if program is SUID or SGID enabled.
  96     const char *dir = 0;
  97     (dir = std::getenv("TMPDIR" )) ||
  98     (dir = std::getenv("TMP"    )) ||
  99     (dir = std::getenv("TEMP"   )) ||
 100     (dir = std::getenv("TEMPDIR")) ||
 101 #ifdef P_tmpdir
 102     (dir = P_tmpdir) ||
 103 #endif
 104     (dir = "/tmp");
 105
 106     result.clear();
 107     StringRef d(dir);
 108     result.append(d.begin(), d.end());
 109     return error_code::success();
 110   }
 111 }
 112
 113 namespace llvm {
 114 namespace sys  {
 115 namespace fs {
 116 #if defined(__FreeBSD__) || defined (__NetBSD__) || defined(__Bitrig__) || \
 117     defined(__OpenBSD__) || defined(__minix) || defined(__FreeBSD_kernel__) || \
 118     defined(__linux__) || defined(__CYGWIN__)
 119 static int
 120 test_dir(char buf[PATH_MAX], char ret[PATH_MAX],
 121     const char *dir, const char *bin)
 122 {
 123   struct stat sb;
 124
 125   snprintf(buf, PATH_MAX, "%s/%s", dir, bin);
 126   if (realpath(buf, ret) == NULL)
 127     return (1);
 128   if (stat(buf, &sb) != 0)
 129     return (1);
 130
 131   return (0);
 132 }
 133
 134 static char *
 135 getprogpath(char ret[PATH_MAX], const char *bin)
 136 {
 137   char *pv, *s, *t, buf[PATH_MAX];
 138
 139   /* First approach: absolute path. */
 140   if (bin[0] == '/') {
 141     if (test_dir(buf, ret, "/", bin) == 0)
 142       return (ret);
 143     return (NULL);
 144   }
 145
 146   /* Second approach: relative path. */
 147   if (strchr(bin, '/') != NULL) {
 148     if (getcwd(buf, PATH_MAX) == NULL)
 149       return (NULL);
 150     if (test_dir(buf, ret, buf, bin) == 0)
 151       return (ret);
 152     return (NULL);
 153   }
 154
 155   /* Third approach: $PATH */
 156   if ((pv = getenv("PATH")) == NULL)
 157     return (NULL);
 158   s = pv = strdup(pv);
 159   if (pv == NULL)
 160     return (NULL);
 161   while ((t = strsep(&s, ":")) != NULL) {
 162     if (test_dir(buf, ret, t, bin) == 0) {
 163       free(pv);
 164       return (ret);
 165     }
 166   }
 167   free(pv);
 168   return (NULL);
 169 }
 170 #endif // __FreeBSD__ || __NetBSD__ || __FreeBSD_kernel__
 171
 172 /// GetMainExecutable - Return the path to the main executable, given the
 173 /// value of argv[0] from program startup.
 174 std::string getMainExecutable(const char *argv0, void *MainAddr) {
 175 #if defined(__APPLE__)
 176   // On OS X the executable path is saved to the stack by dyld. Reading it
 177   // from there is much faster than calling dladdr, especially for large
 178   // binaries with symbols.
 179   char exe_path[MAXPATHLEN];
 180   uint32_t size = sizeof(exe_path);
 181   if (_NSGetExecutablePath(exe_path, &size) == 0) {
 182     char link_path[MAXPATHLEN];
 183     if (realpath(exe_path, link_path))
 184       return link_path;
 185   }
 186 #elif defined(__FreeBSD__) || defined (__NetBSD__) || defined(__Bitrig__) || \
 187       defined(__OpenBSD__) || defined(__minix) || defined(__FreeBSD_kernel__)
 188   char exe_path[PATH_MAX];
 189
 190   if (getprogpath(exe_path, argv0) != NULL)
 191     return exe_path;
 192 #elif defined(__linux__) || defined(__CYGWIN__)
 193   char exe_path[MAXPATHLEN];
 194   StringRef aPath("/proc/self/exe");
 195   if (sys::fs::exists(aPath)) {
 196       // /proc is not always mounted under Linux (chroot for example).
 197       ssize_t len = readlink(aPath.str().c_str(), exe_path, sizeof(exe_path));
 198       if (len >= 0)
 199           return StringRef(exe_path, len);
 200   } else {
 201       // Fall back to the classical detection.
 202       if (getprogpath(exe_path, argv0) != NULL)
 203           return exe_path;
 204   }
 205 #elif defined(HAVE_DLFCN_H)
 206   // Use dladdr to get executable path if available.
 207   Dl_info DLInfo;
 208   int err = dladdr(MainAddr, &DLInfo);
 209   if (err == 0)
 210     return "";
 211
 212   // If the filename is a symlink, we need to resolve and return the location of
 213   // the actual executable.
 214   char link_path[MAXPATHLEN];
 215   if (realpath(DLInfo.dli_fname, link_path))
 216     return link_path;
 217 #else
 218 #error GetMainExecutable is not implemented on this host yet.
 219 #endif
 220   return "";
 221 }
 222
 223 TimeValue file_status::getLastModificationTime() const {
 224   TimeValue Ret;
 225   Ret.fromEpochTime(fs_st_mtime);
 226   return Ret;
 227 }
 228
 229 error_code current_path(SmallVectorImpl<char> &result) {
 230 #ifdef MAXPATHLEN
 231   result.reserve(MAXPATHLEN);
 232 #else
 233 // For GNU Hurd
 234   result.reserve(1024);
 235 #endif
 236
 237   while (true) {
 238     if (::getcwd(result.data(), result.capacity()) == 0) {
 239       // See if there was a real error.
 240       if (errno != errc::not_enough_memory)
 241         return error_code(errno, system_category());
 242       // Otherwise there just wasn't enough space.
 243       result.reserve(result.capacity() * 2);
 244     } else
 245       break;
 246   }
 247
 248   result.set_size(strlen(result.data()));
 249   return error_code::success();
 250 }
 251
 252 error_code copy_file(const Twine &from, const Twine &to, copy_option copt) {
 253  // Get arguments.
 254   SmallString<128> from_storage;
 255   SmallString<128> to_storage;
 256   StringRef f = from.toNullTerminatedStringRef(from_storage);
 257   StringRef t = to.toNullTerminatedStringRef(to_storage);
 258
 259   const size_t buf_sz = 32768;
 260   char buffer[buf_sz];
 261   int from_file = -1, to_file = -1;
 262
 263   // Open from.
 264   if ((from_file = ::open(f.begin(), O_RDONLY)) < 0)
 265     return error_code(errno, system_category());
 266   AutoFD from_fd(from_file);
 267
 268   // Stat from.
 269   struct stat from_stat;
 270   if (::stat(f.begin(), &from_stat) != 0)
 271     return error_code(errno, system_category());
 272
 273   // Setup to flags.
 274   int to_flags = O_CREAT | O_WRONLY;
 275   if (copt == copy_option::fail_if_exists)
 276     to_flags |= O_EXCL;
 277
 278   // Open to.
 279   if ((to_file = ::open(t.begin(), to_flags, from_stat.st_mode)) < 0)
 280     return error_code(errno, system_category());
 281   AutoFD to_fd(to_file);
 282
 283   // Copy!
 284   ssize_t sz, sz_read = 1, sz_write;
 285   while (sz_read > 0 &&
 286          (sz_read = ::read(from_fd, buffer, buf_sz)) > 0) {
 287     // Allow for partial writes - see Advanced Unix Programming (2nd Ed.),
 288     // Marc Rochkind, Addison-Wesley, 2004, page 94
 289     sz_write = 0;
 290     do {
 291       if ((sz = ::write(to_fd, buffer + sz_write, sz_read - sz_write)) < 0) {
 292         sz_read = sz;  // cause read loop termination.
 293         break;         // error.
 294       }
 295       sz_write += sz;
 296     } while (sz_write < sz_read);
 297   }
 298
 299   // After all the file operations above the return value of close actually
 300   // matters.
 301   if (::close(from_fd.take()) < 0) sz_read = -1;
 302   if (::close(to_fd.take()) < 0) sz_read = -1;
 303
 304   // Check for errors.
 305   if (sz_read < 0)
 306     return error_code(errno, system_category());
 307
 308   return error_code::success();
 309 }
 310
 311 error_code create_directory(const Twine &path, bool &existed) {
 312   SmallString<128> path_storage;
 313   StringRef p = path.toNullTerminatedStringRef(path_storage);
 314
 315   if (::mkdir(p.begin(), S_IRWXU | S_IRWXG) == -1) {
 316     if (errno != errc::file_exists)
 317       return error_code(errno, system_category());
 318     existed = true;
 319   } else
 320     existed = false;
 321
 322   return error_code::success();
 323 }
 324
 325 error_code create_hard_link(const Twine &to, const Twine &from) {
 326   // Get arguments.
 327   SmallString<128> from_storage;
 328   SmallString<128> to_storage;
 329   StringRef f = from.toNullTerminatedStringRef(from_storage);
 330   StringRef t = to.toNullTerminatedStringRef(to_storage);
 331
 332   if (::link(t.begin(), f.begin()) == -1)
 333     return error_code(errno, system_category());
 334
 335   return error_code::success();
 336 }
 337
 338 error_code create_symlink(const Twine &to, const Twine &from) {
 339   // Get arguments.
 340   SmallString<128> from_storage;
 341   SmallString<128> to_storage;
 342   StringRef f = from.toNullTerminatedStringRef(from_storage);
 343   StringRef t = to.toNullTerminatedStringRef(to_storage);
 344
 345   if (::symlink(t.begin(), f.begin()) == -1)
 346     return error_code(errno, system_category());
 347
 348   return error_code::success();
 349 }
 350
 351 error_code remove(const Twine &path, bool &existed) {
 352   SmallString<128> path_storage;
 353   StringRef p = path.toNullTerminatedStringRef(path_storage);
 354
 355   struct stat buf;
 356   if (stat(p.begin(), &buf) != 0) {
 357     if (errno != errc::no_such_file_or_directory)
 358       return error_code(errno, system_category());
 359     existed = false;
 360     return error_code::success();
 361   }
 362
 363   // Note: this check catches strange situations. In all cases, LLVM should
 364   // only be involved in the creation and deletion of regular files.  This
 365   // check ensures that what we're trying to erase is a regular file. It
 366   // effectively prevents LLVM from erasing things like /dev/null, any block
 367   // special file, or other things that aren't "regular" files.
 368   if (!S_ISREG(buf.st_mode) && !S_ISDIR(buf.st_mode))
 369     return make_error_code(errc::operation_not_permitted);
 370
 371   if (::remove(p.begin()) == -1) {
 372     if (errno != errc::no_such_file_or_directory)
 373       return error_code(errno, system_category());
 374     existed = false;
 375   } else
 376     existed = true;
 377
 378   return error_code::success();
 379 }
 380
 381 error_code rename(const Twine &from, const Twine &to) {
 382   // Get arguments.
 383   SmallString<128> from_storage;
 384   SmallString<128> to_storage;
 385   StringRef f = from.toNullTerminatedStringRef(from_storage);
 386   StringRef t = to.toNullTerminatedStringRef(to_storage);
 387
 388   if (::rename(f.begin(), t.begin()) == -1) {
 389     // If it's a cross device link, copy then delete, otherwise return the error
 390     if (errno == EXDEV) {
 391       if (error_code ec = copy_file(from, to, copy_option::overwrite_if_exists))
 392         return ec;
 393       bool Existed;
 394       if (error_code ec = remove(from, Existed))
 395         return ec;
 396     } else
 397       return error_code(errno, system_category());
 398   }
 399
 400   return error_code::success();
 401 }
 402
 403 error_code resize_file(const Twine &path, uint64_t size) {
 404   SmallString<128> path_storage;
 405   StringRef p = path.toNullTerminatedStringRef(path_storage);
 406
 407   if (::truncate(p.begin(), size) == -1)
 408     return error_code(errno, system_category());
 409
 410   return error_code::success();
 411 }
 412
 413 error_code exists(const Twine &path, bool &result) {
 414   SmallString<128> path_storage;
 415   StringRef p = path.toNullTerminatedStringRef(path_storage);
 416
 417   if (::access(p.begin(), F_OK) == -1) {
 418     if (errno != errc::no_such_file_or_directory)
 419       return error_code(errno, system_category());
 420     result = false;
 421   } else
 422     result = true;
 423
 424   return error_code::success();
 425 }
 426
 427 bool can_write(const Twine &Path) {
 428   SmallString<128> PathStorage;
 429   StringRef P = Path.toNullTerminatedStringRef(PathStorage);
 430   return 0 == access(P.begin(), W_OK);
 431 }
 432
 433 bool can_execute(const Twine &Path) {
 434   SmallString<128> PathStorage;
 435   StringRef P = Path.toNullTerminatedStringRef(PathStorage);
 436
 437   if (0 != access(P.begin(), R_OK | X_OK))
 438     return false;
 439   struct stat buf;
 440   if (0 != stat(P.begin(), &buf))
 441     return false;
 442   if (!S_ISREG(buf.st_mode))
 443     return false;
 444   return true;
 445 }
 446
 447 bool equivalent(file_status A, file_status B) {
 448   assert(status_known(A) && status_known(B));
 449   return A.fs_st_dev == B.fs_st_dev &&
 450          A.fs_st_ino == B.fs_st_ino;
 451 }
 452
 453 error_code equivalent(const Twine &A, const Twine &B, bool &result) {
 454   file_status fsA, fsB;
 455   if (error_code ec = status(A, fsA)) return ec;
 456   if (error_code ec = status(B, fsB)) return ec;
 457   result = equivalent(fsA, fsB);
 458   return error_code::success();
 459 }
 460
 461 error_code file_size(const Twine &path, uint64_t &result) {
 462   SmallString<128> path_storage;
 463   StringRef p = path.toNullTerminatedStringRef(path_storage);
 464
 465   struct stat status;
 466   if (::stat(p.begin(), &status) == -1)
 467     return error_code(errno, system_category());
 468   if (!S_ISREG(status.st_mode))
 469     return make_error_code(errc::operation_not_permitted);
 470
 471   result = status.st_size;
 472   return error_code::success();
 473 }
 474
 475 error_code getUniqueID(const Twine Path, uint64_t &Result) {
 476   SmallString<128> Storage;
 477   StringRef P = Path.toNullTerminatedStringRef(Storage);
 478
 479   struct stat Status;
 480   if (::stat(P.begin(), &Status) != 0)
 481     return error_code(errno, system_category());
 482
 483   Result = Status.st_ino;
 484   return error_code::success();
 485 }
 486
 487 error_code status(const Twine &path, file_status &result) {
 488   SmallString<128> path_storage;
 489   StringRef p = path.toNullTerminatedStringRef(path_storage);
 490
 491   struct stat status;
 492   if (::stat(p.begin(), &status) != 0) {
 493     error_code ec(errno, system_category());
 494     if (ec == errc::no_such_file_or_directory)
 495       result = file_status(file_type::file_not_found);
 496     else
 497       result = file_status(file_type::status_error);
 498     return ec;
 499   }
 500
 501   perms prms = static_cast<perms>(status.st_mode & perms_mask);
 502
 503   if (S_ISDIR(status.st_mode))
 504     result = file_status(file_type::directory_file, prms);
 505   else if (S_ISREG(status.st_mode))
 506     result = file_status(file_type::regular_file, prms);
 507   else if (S_ISBLK(status.st_mode))
 508     result = file_status(file_type::block_file, prms);
 509   else if (S_ISCHR(status.st_mode))
 510     result = file_status(file_type::character_file, prms);
 511   else if (S_ISFIFO(status.st_mode))
 512     result = file_status(file_type::fifo_file, prms);
 513   else if (S_ISSOCK(status.st_mode))
 514     result = file_status(file_type::socket_file, prms);
 515   else
 516     result = file_status(file_type::type_unknown, prms);
 517
 518   result.fs_st_dev = status.st_dev;
 519   result.fs_st_ino = status.st_ino;
 520   result.fs_st_mtime = status.st_mtime;
 521   result.fs_st_uid = status.st_uid;
 522   result.fs_st_gid = status.st_gid;
 523
 524   return error_code::success();
 525 }
 526
 527 // Modifies permissions on a file.
 528 error_code permissions(const Twine &path, perms prms) {
 529   if ((prms & add_perms) && (prms & remove_perms))
 530     llvm_unreachable("add_perms and remove_perms are mutually exclusive");
 531
 532   // Get current permissions
 533   // FIXME: We only need this stat for add_perms and remove_perms.
 534   file_status info;
 535   if (error_code ec = status(path, info)) {
 536     return ec;
 537   }
 538
 539   // Set updated permissions.
 540   SmallString<128> path_storage;
 541   StringRef p = path.toNullTerminatedStringRef(path_storage);
 542   perms permsToSet;
 543   if (prms & add_perms) {
 544     permsToSet = (info.permissions() | prms) & perms_mask;
 545   } else if (prms & remove_perms) {
 546     permsToSet = (info.permissions() & ~prms) & perms_mask;
 547   } else {
 548     permsToSet = prms & perms_mask;
 549   }
 550   if (::chmod(p.begin(), static_cast<mode_t>(permsToSet))) {
 551     return error_code(errno, system_category());
 552   }
 553
 554   return error_code::success();
 555 }
 556
 557 error_code setLastModificationAndAccessTime(int FD, TimeValue Time) {
 558   timeval Times[2];
 559   Times[0].tv_sec = Time.toPosixTime();
 560   Times[0].tv_usec = 0;
 561   Times[1] = Times[0];
 562   if (::futimes(FD, Times))
 563     return error_code(errno, system_category());
 564   return error_code::success();
 565 }
 566
 567 // Since this is most often used for temporary files, mode defaults to 0600.
 568 error_code unique_file(const Twine &model, int &result_fd,
 569                        SmallVectorImpl<char> &result_path,
 570                        bool makeAbsolute, unsigned mode) {
 571   SmallString<128> Model;
 572   model.toVector(Model);
 573   // Null terminate.
 574   Model.c_str();
 575
 576   if (makeAbsolute) {
 577     // Make model absolute by prepending a temp directory if it's not already.
 578     bool absolute = path::is_absolute(Twine(Model));
 579     if (!absolute) {
 580       SmallString<128> TDir;
 581       if (error_code ec = TempDir(TDir)) return ec;
 582       path::append(TDir, Twine(Model));
 583       Model.swap(TDir);
 584     }
 585   }
 586
 587   // From here on, DO NOT modify model. It may be needed if the randomly chosen
 588   // path already exists.
 589   SmallString<128> RandomPath = Model;
 590
 591 retry_random_path:
 592   // Replace '%' with random chars.
 593   for (unsigned i = 0, e = Model.size(); i != e; ++i) {
 594     if (Model[i] == '%')
 595       RandomPath[i] = "0123456789abcdef"[sys::Process::GetRandomNumber() & 15];
 596   }
 597
 598   // Make sure we don't fall into an infinite loop by constantly trying
 599   // to create the parent path.
 600   bool TriedToCreateParent = false;
 601
 602   // Try to open + create the file.
 603 rety_open_create:
 604   int RandomFD = ::open(RandomPath.c_str(), O_RDWR | O_CREAT | O_EXCL, mode);
 605   if (RandomFD == -1) {
 606     int SavedErrno = errno;
 607     // If the file existed, try again, otherwise, error.
 608     if (SavedErrno == errc::file_exists)
 609       goto retry_random_path;
 610     // If path prefix doesn't exist, try to create it.
 611     if (SavedErrno == errc::no_such_file_or_directory && !TriedToCreateParent) {
 612       TriedToCreateParent = true;
 613       StringRef p(RandomPath);
 614       SmallString<64> dir_to_create;
 615       for (path::const_iterator i = path::begin(p),
 616                                 e = --path::end(p); i != e; ++i) {
 617         path::append(dir_to_create, *i);
 618         bool Exists;
 619         if (error_code ec = exists(Twine(dir_to_create), Exists)) return ec;
 620         if (!Exists) {
 621           // Don't try to create network paths.
 622           if (i->size() > 2 && (*i)[0] == '/' &&
 623                                (*i)[1] == '/' &&
 624                                (*i)[2] != '/')
 625             return make_error_code(errc::no_such_file_or_directory);
 626           if (::mkdir(dir_to_create.c_str(), 0700) == -1 &&
 627               errno != errc::file_exists)
 628             return error_code(errno, system_category());
 629         }
 630       }
 631       goto rety_open_create;
 632     }
 633
 634     return error_code(SavedErrno, system_category());
 635   }
 636
 637    // Make the path absolute.
 638   char real_path_buff[PATH_MAX + 1];
 639   if (realpath(RandomPath.c_str(), real_path_buff) == NULL) {
 640     int error = errno;
 641     ::close(RandomFD);
 642     ::unlink(RandomPath.c_str());
 643     return error_code(error, system_category());
 644   }
 645
 646   result_path.clear();
 647   StringRef d(real_path_buff);
 648   result_path.append(d.begin(), d.end());
 649
 650   result_fd = RandomFD;
 651   return error_code::success();
 652 }
 653
 654 error_code mapped_file_region::init(int FD, bool CloseFD, uint64_t Offset) {
 655   AutoFD ScopedFD(FD);
 656   if (!CloseFD)
 657     ScopedFD.take();
 658
 659   // Figure out how large the file is.
 660   struct stat FileInfo;
 661   if (fstat(FD, &FileInfo) == -1)
 662     return error_code(errno, system_category());
 663   uint64_t FileSize = FileInfo.st_size;
 664
 665   if (Size == 0)
 666     Size = FileSize;
 667   else if (FileSize < Size) {
 668     // We need to grow the file.
 669     if (ftruncate(FD, Size) == -1)
 670       return error_code(errno, system_category());
 671   }
 672
 673   int flags = (Mode == readwrite) ? MAP_SHARED : MAP_PRIVATE;
 674   int prot = (Mode == readonly) ? PROT_READ : (PROT_READ | PROT_WRITE);
 675 #ifdef MAP_FILE
 676   flags |= MAP_FILE;
 677 #endif
 678   Mapping = ::mmap(0, Size, prot, flags, FD, Offset);
 679   if (Mapping == MAP_FAILED)
 680     return error_code(errno, system_category());
 681   return error_code::success();
 682 }
 683
 684 mapped_file_region::mapped_file_region(const Twine &path,
 685                                        mapmode mode,
 686                                        uint64_t length,
 687                                        uint64_t offset,
 688                                        error_code &ec)
 689   : Mode(mode)
 690   , Size(length)
 691   , Mapping() {
 692   // Make sure that the requested size fits within SIZE_T.
 693   if (length > std::numeric_limits<size_t>::max()) {
 694     ec = make_error_code(errc::invalid_argument);
 695     return;
 696   }
 697
 698   SmallString<128> path_storage;
 699   StringRef name = path.toNullTerminatedStringRef(path_storage);
 700   int oflags = (mode == readonly) ? O_RDONLY : O_RDWR;
 701   int ofd = ::open(name.begin(), oflags);
 702   if (ofd == -1) {
 703     ec = error_code(errno, system_category());
 704     return;
 705   }
 706
 707   ec = init(ofd, true, offset);
 708   if (ec)
 709     Mapping = 0;
 710 }
 711
 712 mapped_file_region::mapped_file_region(int fd,
 713                                        bool closefd,
 714                                        mapmode mode,
 715                                        uint64_t length,
 716                                        uint64_t offset,
 717                                        error_code &ec)
 718   : Mode(mode)
 719   , Size(length)
 720   , Mapping() {
 721   // Make sure that the requested size fits within SIZE_T.
 722   if (length > std::numeric_limits<size_t>::max()) {
 723     ec = make_error_code(errc::invalid_argument);
 724     return;
 725   }
 726
 727   ec = init(fd, closefd, offset);
 728   if (ec)
 729     Mapping = 0;
 730 }
 731
 732 mapped_file_region::~mapped_file_region() {
 733   if (Mapping)
 734     ::munmap(Mapping, Size);
 735 }
 736
 737 #if LLVM_HAS_RVALUE_REFERENCES
 738 mapped_file_region::mapped_file_region(mapped_file_region &&other)
 739   : Mode(other.Mode), Size(other.Size), Mapping(other.Mapping) {
 740   other.Mapping = 0;
 741 }
 742 #endif
 743
 744 mapped_file_region::mapmode mapped_file_region::flags() const {
 745   assert(Mapping && "Mapping failed but used anyway!");
 746   return Mode;
 747 }
 748
 749 uint64_t mapped_file_region::size() const {
 750   assert(Mapping && "Mapping failed but used anyway!");
 751   return Size;
 752 }
 753
 754 char *mapped_file_region::data() const {
 755   assert(Mapping && "Mapping failed but used anyway!");
 756   assert(Mode != readonly && "Cannot get non const data for readonly mapping!");
 757   return reinterpret_cast<char*>(Mapping);
 758 }
 759
 760 const char *mapped_file_region::const_data() const {
 761   assert(Mapping && "Mapping failed but used anyway!");
 762   return reinterpret_cast<const char*>(Mapping);
 763 }
 764
 765 int mapped_file_region::alignment() {
 766   return process::get_self()->page_size();
 767 }
 768
 769 error_code detail::directory_iterator_construct(detail::DirIterState &it,
 770                                                 StringRef path){
 771   SmallString<128> path_null(path);
 772   DIR *directory = ::opendir(path_null.c_str());
 773   if (directory == 0)
 774     return error_code(errno, system_category());
 775
 776   it.IterationHandle = reinterpret_cast<intptr_t>(directory);
 777   // Add something for replace_filename to replace.
 778   path::append(path_null, ".");
 779   it.CurrentEntry = directory_entry(path_null.str());
 780   return directory_iterator_increment(it);
 781 }
 782
 783 error_code detail::directory_iterator_destruct(detail::DirIterState &it) {
 784   if (it.IterationHandle)
 785     ::closedir(reinterpret_cast<DIR *>(it.IterationHandle));
 786   it.IterationHandle = 0;
 787   it.CurrentEntry = directory_entry();
 788   return error_code::success();
 789 }
 790
 791 error_code detail::directory_iterator_increment(detail::DirIterState &it) {
 792   errno = 0;
 793   dirent *cur_dir = ::readdir(reinterpret_cast<DIR *>(it.IterationHandle));
 794   if (cur_dir == 0 && errno != 0) {
 795     return error_code(errno, system_category());
 796   } else if (cur_dir != 0) {
 797     StringRef name(cur_dir->d_name, NAMLEN(cur_dir));
 798     if ((name.size() == 1 && name[0] == '.') ||
 799         (name.size() == 2 && name[0] == '.' && name[1] == '.'))
 800       return directory_iterator_increment(it);
 801     it.CurrentEntry.replace_filename(name);
 802   } else
 803     return directory_iterator_destruct(it);
 804
 805   return error_code::success();
 806 }
 807
 808 error_code get_magic(const Twine &path, uint32_t len,
 809                      SmallVectorImpl<char> &result) {
 810   SmallString<128> PathStorage;
 811   StringRef Path = path.toNullTerminatedStringRef(PathStorage);
 812   result.set_size(0);
 813
 814   // Open path.
 815   std::FILE *file = std::fopen(Path.data(), "rb");
 816   if (file == 0)
 817     return error_code(errno, system_category());
 818
 819   // Reserve storage.
 820   result.reserve(len);
 821
 822   // Read magic!
 823   size_t size = std::fread(result.data(), 1, len, file);
 824   if (std::ferror(file) != 0) {
 825     std::fclose(file);
 826     return error_code(errno, system_category());
 827   } else if (size != len) {
 828     if (std::feof(file) != 0) {
 829       std::fclose(file);
 830       result.set_size(size);
 831       return make_error_code(errc::value_too_large);
 832     }
 833   }
 834   std::fclose(file);
 835   result.set_size(size);
 836   return error_code::success();
 837 }
 838
 839 error_code map_file_pages(const Twine &path, off_t file_offset, size_t size,
 840                                             bool map_writable, void *&result) {
 841   SmallString<128> path_storage;
 842   StringRef name = path.toNullTerminatedStringRef(path_storage);
 843   int oflags = map_writable ? O_RDWR : O_RDONLY;
 844   int ofd = ::open(name.begin(), oflags);
 845   if ( ofd == -1 )
 846     return error_code(errno, system_category());
 847   AutoFD fd(ofd);
 848   int flags = map_writable ? MAP_SHARED : MAP_PRIVATE;
 849   int prot = map_writable ? (PROT_READ|PROT_WRITE) : PROT_READ;
 850 #ifdef MAP_FILE
 851   flags |= MAP_FILE;
 852 #endif
 853   result = ::mmap(0, size, prot, flags, fd, file_offset);
 854   if (result == MAP_FAILED) {
 855     return error_code(errno, system_category());
 856   }
 857
 858   return error_code::success();
 859 }
 860
 861 error_code unmap_file_pages(void *base, size_t size) {
 862   if ( ::munmap(base, size) == -1 )
 863     return error_code(errno, system_category());
 864
 865   return error_code::success();
 866 }
 867
 868
 869 } // end namespace fs
 870 } // end namespace sys
 871 } // end namespace llvm