lib/Support/Unix/Path.inc

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