folly/system/MemoryMapping.cpp

   1 /*
   2  * Copyright 2017 Facebook, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *   http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <folly/system/MemoryMapping.h>
  18
  19 #include <algorithm>
  20 #include <functional>
  21 #include <utility>
  22
  23 #include <folly/Format.h>
  24 #include <folly/portability/GFlags.h>
  25 #include <folly/portability/SysMman.h>
  26
  27 #ifdef __linux__
  28 #include <folly/experimental/io/HugePages.h>
  29 #endif
  30
  31 #include <fcntl.h>
  32 #include <sys/types.h>
  33 #include <system_error>
  34
  35 static constexpr ssize_t kDefaultMlockChunkSize =
  36 #ifndef _MSC_VER
  37     // Linux implementations of unmap/mlock/munlock take a kernel
  38     // semaphore and block other threads from doing other memory
  39     // operations. Split the operations in chunks.
  40     (1 << 20) // 1MB
  41 #else // _MSC_VER
  42     // MSVC doesn't have this problem, and calling munmap many times
  43     // with the same address is a bad idea with the windows implementation.
  44     (-1)
  45 #endif // _MSC_VER
  46     ;
  47
  48 DEFINE_int64(mlock_chunk_size, kDefaultMlockChunkSize,
  49              "Maximum bytes to mlock/munlock/munmap at once "
  50              "(will be rounded up to PAGESIZE). Ignored if negative.");
  51
  52 #ifndef MAP_POPULATE
  53 #define MAP_POPULATE 0
  54 #endif
  55
  56 namespace folly {
  57
  58 MemoryMapping::MemoryMapping(MemoryMapping&& other) noexcept {
  59   swap(other);
  60 }
  61
  62 MemoryMapping::MemoryMapping(File file, off_t offset, off_t length,
  63                              Options options)
  64   : file_(std::move(file)),
  65     options_(std::move(options)) {
  66   CHECK(file_);
  67   init(offset, length);
  68 }
  69
  70 MemoryMapping::MemoryMapping(const char* name, off_t offset, off_t length,
  71                              Options options)
  72     : MemoryMapping(File(name, options.writable ? O_RDWR : O_RDONLY),
  73                     offset,
  74                     length,
  75                     options) { }
  76
  77 MemoryMapping::MemoryMapping(int fd, off_t offset, off_t length,
  78                              Options options)
  79   : MemoryMapping(File(fd), offset, length, options) { }
  80
  81 MemoryMapping::MemoryMapping(AnonymousType, off_t length, Options options)
  82   : options_(std::move(options)) {
  83   init(0, length);
  84 }
  85
  86 namespace {
  87
  88 #ifdef __linux__
  89 void getDeviceOptions(dev_t device, off_t& pageSize, bool& autoExtend) {
  90   auto ps = getHugePageSizeForDevice(device);
  91   if (ps) {
  92     pageSize = ps->size;
  93     autoExtend = true;
  94   }
  95 }
  96 #else
  97 inline void getDeviceOptions(dev_t, off_t&, bool&) {}
  98 #endif
  99
 100 } // namespace
 101
 102 void MemoryMapping::init(off_t offset, off_t length) {
 103   const bool grow = options_.grow;
 104   const bool anon = !file_;
 105   CHECK(!(grow && anon));
 106
 107   off_t& pageSize = options_.pageSize;
 108
 109   struct stat st;
 110
 111   // On Linux, hugetlbfs file systems don't require ftruncate() to grow the
 112   // file, and (on kernels before 2.6.24) don't even allow it. Also, the file
 113   // size is always a multiple of the page size.
 114   bool autoExtend = false;
 115
 116   if (!anon) {
 117     // Stat the file
 118     CHECK_ERR(fstat(file_.fd(), &st));
 119
 120     if (pageSize == 0) {
 121       getDeviceOptions(st.st_dev, pageSize, autoExtend);
 122     }
 123   } else {
 124     DCHECK(!file_);
 125     DCHECK_EQ(offset, 0);
 126     CHECK_EQ(pageSize, 0);
 127     CHECK_GE(length, 0);
 128   }
 129
 130   if (pageSize == 0) {
 131     pageSize = off_t(sysconf(_SC_PAGESIZE));
 132   }
 133
 134   CHECK_GT(pageSize, 0);
 135   CHECK_EQ(pageSize & (pageSize - 1), 0);  // power of two
 136   CHECK_GE(offset, 0);
 137
 138   // Round down the start of the mapped region
 139   off_t skipStart = offset % pageSize;
 140   offset -= skipStart;
 141
 142   mapLength_ = length;
 143   if (mapLength_ != -1) {
 144     mapLength_ += skipStart;
 145
 146     // Round up the end of the mapped region
 147     mapLength_ = (mapLength_ + pageSize - 1) / pageSize * pageSize;
 148   }
 149
 150   off_t remaining = anon ? length : st.st_size - offset;
 151
 152   if (mapLength_ == -1) {
 153     length = mapLength_ = remaining;
 154   } else {
 155     if (length > remaining) {
 156       if (grow) {
 157         if (!autoExtend) {
 158           PCHECK(0 == ftruncate(file_.fd(), offset + length))
 159             << "ftruncate() failed, couldn't grow file to "
 160             << offset + length;
 161           remaining = length;
 162         } else {
 163           // Extend mapping to multiple of page size, don't use ftruncate
 164           remaining = mapLength_;
 165         }
 166       } else {
 167         length = remaining;
 168       }
 169     }
 170     if (mapLength_ > remaining) {
 171       mapLength_ = remaining;
 172     }
 173   }
 174
 175   if (length == 0) {
 176     mapLength_ = 0;
 177     mapStart_ = nullptr;
 178   } else {
 179     int flags = options_.shared ? MAP_SHARED : MAP_PRIVATE;
 180     if (anon) {
 181       flags |= MAP_ANONYMOUS;
 182     }
 183     if (options_.prefault) {
 184       flags |= MAP_POPULATE;
 185     }
 186
 187     // The standard doesn't actually require PROT_NONE to be zero...
 188     int prot = PROT_NONE;
 189     if (options_.readable || options_.writable) {
 190       prot = ((options_.readable ? PROT_READ : 0) |
 191               (options_.writable ? PROT_WRITE : 0));
 192     }
 193
 194     unsigned char* start = static_cast<unsigned char*>(mmap(
 195         options_.address, size_t(mapLength_), prot, flags, file_.fd(), offset));
 196     PCHECK(start != MAP_FAILED)
 197       << " offset=" << offset
 198       << " length=" << mapLength_;
 199     mapStart_ = start;
 200     data_.reset(start + skipStart, size_t(length));
 201   }
 202 }
 203
 204 namespace {
 205
 206 off_t memOpChunkSize(off_t length, off_t pageSize) {
 207   off_t chunkSize = length;
 208   if (FLAGS_mlock_chunk_size <= 0) {
 209     return chunkSize;
 210   }
 211
 212   chunkSize = off_t(FLAGS_mlock_chunk_size);
 213   off_t r = chunkSize % pageSize;
 214   if (r) {
 215     chunkSize += (pageSize - r);
 216   }
 217   return chunkSize;
 218 }
 219
 220 /**
 221  * Run @op in chunks over the buffer @mem of @bufSize length.
 222  *
 223  * Return:
 224  * - success: true + amountSucceeded == bufSize (op success on whole buffer)
 225  * - failure: false + amountSucceeded == nr bytes on which op succeeded.
 226  */
 227 bool memOpInChunks(std::function<int(void*, size_t)> op,
 228                    void* mem, size_t bufSize, off_t pageSize,
 229                    size_t& amountSucceeded) {
 230   // Linux' unmap/mlock/munlock take a kernel semaphore and block other threads
 231   // from doing other memory operations. If the size of the buffer is big the
 232   // semaphore can be down for seconds (for benchmarks see
 233   // http://kostja-osipov.livejournal.com/42963.html).  Doing the operations in
 234   // chunks breaks the locking into intervals and lets other threads do memory
 235   // operations of their own.
 236
 237   size_t chunkSize = size_t(memOpChunkSize(off_t(bufSize), pageSize));
 238
 239   char* addr = static_cast<char*>(mem);
 240   amountSucceeded = 0;
 241
 242   while (amountSucceeded < bufSize) {
 243     size_t size = std::min(chunkSize, bufSize - amountSucceeded);
 244     if (op(addr + amountSucceeded, size) != 0) {
 245       return false;
 246     }
 247     amountSucceeded += size;
 248   }
 249
 250   return true;
 251 }
 252
 253 } // namespace
 254
 255 bool MemoryMapping::mlock(LockMode lock) {
 256   size_t amountSucceeded = 0;
 257   locked_ = memOpInChunks(
 258       ::mlock,
 259       mapStart_,
 260       size_t(mapLength_),
 261       options_.pageSize,
 262       amountSucceeded);
 263   if (locked_) {
 264     return true;
 265   }
 266
 267   auto msg =
 268       folly::format("mlock({}) failed at {}", mapLength_, amountSucceeded);
 269   if (lock == LockMode::TRY_LOCK && errno == EPERM) {
 270     PLOG(WARNING) << msg;
 271   } else if (lock == LockMode::TRY_LOCK && errno == ENOMEM) {
 272     VLOG(1) << msg;
 273   } else {
 274     PLOG(FATAL) << msg;
 275   }
 276
 277   // only part of the buffer was mlocked, unlock it back
 278   if (!memOpInChunks(::munlock, mapStart_, amountSucceeded, options_.pageSize,
 279                      amountSucceeded)) {
 280     PLOG(WARNING) << "munlock()";
 281   }
 282
 283   return false;
 284 }
 285
 286 void MemoryMapping::munlock(bool dontneed) {
 287   if (!locked_) {
 288     return;
 289   }
 290
 291   size_t amountSucceeded = 0;
 292   if (!memOpInChunks(
 293           ::munlock,
 294           mapStart_,
 295           size_t(mapLength_),
 296           options_.pageSize,
 297           amountSucceeded)) {
 298     PLOG(WARNING) << "munlock()";
 299   }
 300   if (mapLength_ && dontneed &&
 301       ::madvise(mapStart_, size_t(mapLength_), MADV_DONTNEED)) {
 302     PLOG(WARNING) << "madvise()";
 303   }
 304   locked_ = false;
 305 }
 306
 307 void MemoryMapping::hintLinearScan() {
 308   advise(MADV_SEQUENTIAL);
 309 }
 310
 311 MemoryMapping::~MemoryMapping() {
 312   if (mapLength_) {
 313     size_t amountSucceeded = 0;
 314     if (!memOpInChunks(
 315             ::munmap,
 316             mapStart_,
 317             size_t(mapLength_),
 318             options_.pageSize,
 319             amountSucceeded)) {
 320       PLOG(FATAL) << folly::format("munmap({}) failed at {}",
 321                                    mapLength_, amountSucceeded);
 322     }
 323   }
 324 }
 325
 326 void MemoryMapping::advise(int advice) const {
 327   advise(advice, 0, size_t(mapLength_));
 328 }
 329
 330 void MemoryMapping::advise(int advice, size_t offset, size_t length) const {
 331   CHECK_LE(offset + length, size_t(mapLength_))
 332     << " offset: " << offset
 333     << " length: " << length
 334     << " mapLength_: " << mapLength_;
 335
 336   // Include the entire start page: round down to page boundary.
 337   const auto offMisalign = offset % options_.pageSize;
 338   offset -= offMisalign;
 339   length += offMisalign;
 340
 341   // Round the last page down to page boundary.
 342   if (offset + length != size_t(mapLength_)) {
 343     length -= length % options_.pageSize;
 344   }
 345
 346   if (length == 0) {
 347     return;
 348   }
 349
 350   char* mapStart = static_cast<char*>(mapStart_) + offset;
 351   PLOG_IF(WARNING, ::madvise(mapStart, length, advice)) << "madvise";
 352 }
 353
 354 MemoryMapping& MemoryMapping::operator=(MemoryMapping other) {
 355   swap(other);
 356   return *this;
 357 }
 358
 359 void MemoryMapping::swap(MemoryMapping& other) noexcept {
 360   using std::swap;
 361   swap(this->file_, other.file_);
 362   swap(this->mapStart_, other.mapStart_);
 363   swap(this->mapLength_, other.mapLength_);
 364   swap(this->options_, other.options_);
 365   swap(this->locked_, other.locked_);
 366   swap(this->data_, other.data_);
 367 }
 368
 369 void swap(MemoryMapping& a, MemoryMapping& b) noexcept { a.swap(b); }
 370
 371 void alignedForwardMemcpy(void* dst, const void* src, size_t size) {
 372   assert(reinterpret_cast<uintptr_t>(src) % alignof(unsigned long) == 0);
 373   assert(reinterpret_cast<uintptr_t>(dst) % alignof(unsigned long) == 0);
 374
 375   auto srcl = static_cast<const unsigned long*>(src);
 376   auto dstl = static_cast<unsigned long*>(dst);
 377
 378   while (size >= sizeof(unsigned long)) {
 379     *dstl++ = *srcl++;
 380     size -= sizeof(unsigned long);
 381   }
 382
 383   auto srcc = reinterpret_cast<const unsigned char*>(srcl);
 384   auto dstc = reinterpret_cast<unsigned char*>(dstl);
 385
 386   while (size != 0) {
 387     *dstc++ = *srcc++;
 388     --size;
 389   }
 390 }
 391
 392 void mmapFileCopy(const char* src, const char* dest, mode_t mode) {
 393   MemoryMapping srcMap(src);
 394   srcMap.hintLinearScan();
 395
 396   MemoryMapping destMap(
 397       File(dest, O_RDWR | O_CREAT | O_TRUNC, mode),
 398       0,
 399       off_t(srcMap.range().size()),
 400       MemoryMapping::writable());
 401
 402   alignedForwardMemcpy(destMap.writableRange().data(),
 403                        srcMap.range().data(),
 404                        srcMap.range().size());
 405 }
 406
 407 } // namespace folly