contrib/llvm/tools/lldb/source/Core/DataBufferMemoryMap.cpp

   1 //===-- DataBufferMemoryMap.cpp ---------------------------------*- 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
  11 #include <errno.h>
  12 #include <fcntl.h>
  13 #include <limits.h>
  14 #include <sys/stat.h>
  15 #include <sys/mman.h>
  16
  17 #include "lldb/Core/DataBufferMemoryMap.h"
  18 #include "lldb/Core/Error.h"
  19 #include "lldb/Host/File.h"
  20 #include "lldb/Host/FileSpec.h"
  21 #include "lldb/Host/Host.h"
  22 #include "lldb/Core/Log.h"
  23 #include "lldb/lldb-private-log.h"
  24
  25 using namespace lldb;
  26 using namespace lldb_private;
  27
  28 //----------------------------------------------------------------------
  29 // Default Constructor
  30 //----------------------------------------------------------------------
  31 DataBufferMemoryMap::DataBufferMemoryMap() :
  32     m_mmap_addr(NULL),
  33     m_mmap_size(0),
  34     m_data(NULL),
  35     m_size(0)
  36 {
  37 }
  38
  39 //----------------------------------------------------------------------
  40 // Virtual destructor since this class inherits from a pure virtual
  41 // base class.
  42 //----------------------------------------------------------------------
  43 DataBufferMemoryMap::~DataBufferMemoryMap()
  44 {
  45     Clear();
  46 }
  47
  48 //----------------------------------------------------------------------
  49 // Return a pointer to the bytes owned by this object, or NULL if
  50 // the object contains no bytes.
  51 //----------------------------------------------------------------------
  52 uint8_t *
  53 DataBufferMemoryMap::GetBytes()
  54 {
  55     return m_data;
  56 }
  57
  58 //----------------------------------------------------------------------
  59 // Return a const pointer to the bytes owned by this object, or NULL
  60 // if the object contains no bytes.
  61 //----------------------------------------------------------------------
  62 const uint8_t *
  63 DataBufferMemoryMap::GetBytes() const
  64 {
  65     return m_data;
  66 }
  67
  68 //----------------------------------------------------------------------
  69 // Return the number of bytes this object currently contains.
  70 //----------------------------------------------------------------------
  71 uint64_t
  72 DataBufferMemoryMap::GetByteSize() const
  73 {
  74     return m_size;
  75 }
  76
  77 //----------------------------------------------------------------------
  78 // Reverts this object to an empty state by unmapping any memory
  79 // that is currently owned.
  80 //----------------------------------------------------------------------
  81 void
  82 DataBufferMemoryMap::Clear()
  83 {
  84     if (m_mmap_addr != NULL)
  85     {
  86         Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_MMAP));
  87         if (log)
  88             log->Printf("DataBufferMemoryMap::Clear() m_mmap_addr = %p, m_mmap_size = %zu", m_mmap_addr, m_mmap_size);
  89         ::munmap((void *)m_mmap_addr, m_mmap_size);
  90         m_mmap_addr = NULL;
  91         m_mmap_size = 0;
  92         m_data = NULL;
  93         m_size = 0;
  94     }
  95 }
  96
  97 //----------------------------------------------------------------------
  98 // Memory map "length" bytes from "file" starting "offset"
  99 // bytes into the file. If "length" is set to SIZE_MAX, then
 100 // map as many bytes as possible.
 101 //
 102 // Returns the number of bytes mapped starting from the requested
 103 // offset.
 104 //----------------------------------------------------------------------
 105 size_t
 106 DataBufferMemoryMap::MemoryMapFromFileSpec (const FileSpec* filespec,
 107                                             lldb::offset_t offset,
 108                                             lldb::offset_t length,
 109                                             bool writeable)
 110 {
 111     if (filespec != NULL)
 112     {
 113         Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_MMAP));
 114         if (log)
 115         {
 116             log->Printf("DataBufferMemoryMap::MemoryMapFromFileSpec(file=\"%s\", offset=0x%" PRIx64 ", length=0x%" PRIx64 ", writeable=%i",
 117                         filespec->GetPath().c_str(),
 118                         offset,
 119                         length,
 120                         writeable);
 121         }
 122         char path[PATH_MAX];
 123         if (filespec->GetPath(path, sizeof(path)))
 124         {
 125             uint32_t options = File::eOpenOptionRead;
 126             if (writeable)
 127                 options |= File::eOpenOptionWrite;
 128
 129             File file;
 130             Error error (file.Open(path, options));
 131             if (error.Success())
 132             {
 133                 const bool fd_is_file = true;
 134                 return MemoryMapFromFileDescriptor (file.GetDescriptor(), offset, length, writeable, fd_is_file);
 135             }
 136         }
 137     }
 138     // We should only get here if there was an error
 139     Clear();
 140     return 0;
 141 }
 142
 143
 144 //----------------------------------------------------------------------
 145 // The file descriptor FD is assumed to already be opened as read only
 146 // and the STAT structure is assumed to a valid pointer and already
 147 // containing valid data from a call to stat().
 148 //
 149 // Memory map FILE_LENGTH bytes in FILE starting FILE_OFFSET bytes into
 150 // the file. If FILE_LENGTH is set to SIZE_MAX, then map as many bytes
 151 // as possible.
 152 //
 153 // RETURNS
 154 //  Number of bytes mapped starting from the requested offset.
 155 //----------------------------------------------------------------------
 156 size_t
 157 DataBufferMemoryMap::MemoryMapFromFileDescriptor (int fd,
 158                                                   lldb::offset_t offset,
 159                                                   lldb::offset_t length,
 160                                                   bool writeable,
 161                                                   bool fd_is_file)
 162 {
 163     Clear();
 164     if (fd >= 0)
 165     {
 166         Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_MMAP|LIBLLDB_LOG_VERBOSE));
 167         if (log)
 168         {
 169             log->Printf("DataBufferMemoryMap::MemoryMapFromFileSpec(fd=%i, offset=0x%" PRIx64 ", length=0x%" PRIx64 ", writeable=%i, fd_is_file=%i)",
 170                         fd,
 171                         offset,
 172                         length,
 173                         writeable,
 174                         fd_is_file);
 175         }
 176         struct stat stat;
 177         if (::fstat(fd, &stat) == 0)
 178         {
 179             if (S_ISREG(stat.st_mode) && (stat.st_size > offset))
 180             {
 181                 const size_t max_bytes_available = stat.st_size - offset;
 182                 if (length == SIZE_MAX)
 183                 {
 184                     length = max_bytes_available;
 185                 }
 186                 else if (length > max_bytes_available)
 187                 {
 188                     // Cap the length if too much data was requested
 189                     length = max_bytes_available;
 190                 }
 191
 192                 if (length > 0)
 193                 {
 194                     int prot = PROT_READ;
 195                     if (writeable)
 196                         prot |= PROT_WRITE;
 197
 198                     int flags = MAP_PRIVATE;
 199                     if (fd_is_file)
 200                         flags |= MAP_FILE;
 201
 202                     m_mmap_addr = (uint8_t *)::mmap(NULL, length, prot, flags, fd, offset);
 203                     Error error;
 204
 205                     if (m_mmap_addr == (void*)-1)
 206                     {
 207                         error.SetErrorToErrno ();
 208                         if (error.GetError() == EINVAL)
 209                         {
 210                             // We may still have a shot at memory mapping if we align things correctly
 211                             size_t page_offset = offset % Host::GetPageSize();
 212                             if (page_offset != 0)
 213                             {
 214                                 m_mmap_addr = (uint8_t *)::mmap(NULL, length + page_offset, prot, flags, fd, offset - page_offset);
 215                                 if (m_mmap_addr == (void*)-1)
 216                                 {
 217                                     // Failed to map file
 218                                     m_mmap_addr = NULL;
 219                                 }
 220                                 else if (m_mmap_addr != NULL)
 221                                 {
 222                                     // We recovered and were able to memory map
 223                                     // after we aligned things to page boundaries
 224
 225                                     // Save the actual mmap'ed size
 226                                     m_mmap_size = length + page_offset;
 227                                     // Our data is at an offset into the the mapped data
 228                                     m_data = m_mmap_addr + page_offset;
 229                                     // Our pretend size is the size that was requestd
 230                                     m_size = length;
 231                                 }
 232                             }
 233                         }
 234                         if (error.GetError() == ENOMEM)
 235                         {
 236                            error.SetErrorStringWithFormat("could not allocate %" PRId64 " bytes of memory to mmap in file", (uint64_t) length);
 237                         }
 238                     }
 239                     else
 240                     {
 241                         // We were able to map the requested data in one chunk
 242                         // where our mmap and actual data are the same.
 243                         m_mmap_size = length;
 244                         m_data = m_mmap_addr;
 245                         m_size = length;
 246                     }
 247
 248                     if (log)
 249                     {
 250                         log->Printf("DataBufferMemoryMap::MemoryMapFromFileSpec() m_mmap_addr = %p, m_mmap_size = %zu, error = %s",
 251                                     m_mmap_addr, m_mmap_size, error.AsCString());
 252                     }
 253                 }
 254             }
 255         }
 256     }
 257     return GetByteSize ();
 258 }