FileMap.cpp revision 819b480b935a99fc8114b622644f42dec9e3a177
1/* 2 * Copyright (C) 2006 The Android Open Source Project 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// 18// Shared file mapping class. 19// 20 21#define LOG_TAG "filemap" 22 23#include <utils/FileMap.h> 24#include <utils/Log.h> 25 26#if defined(__MINGW32__) && !defined(__USE_MINGW_ANSI_STDIO) 27# define PRId32 "I32d" 28# define PRIx32 "I32x" 29# define PRId64 "I64d" 30#else 31#include <inttypes.h> 32#endif 33#include <stdio.h> 34#include <stdlib.h> 35 36#if !defined(__MINGW32__) 37#include <sys/mman.h> 38#endif 39 40#include <string.h> 41#include <memory.h> 42#include <errno.h> 43#include <assert.h> 44 45using namespace android; 46 47/*static*/ long FileMap::mPageSize = -1; 48 49// Constructor. Create an empty object. 50FileMap::FileMap(void) 51 : mRefCount(1), mFileName(NULL), mBasePtr(NULL), mBaseLength(0), 52 mDataPtr(NULL), mDataLength(0) 53{ 54} 55 56// Destructor. 57FileMap::~FileMap(void) 58{ 59 assert(mRefCount == 0); 60 61 //printf("+++ removing FileMap %p %zu\n", mDataPtr, mDataLength); 62 63 mRefCount = -100; // help catch double-free 64 if (mFileName != NULL) { 65 free(mFileName); 66 } 67#if defined(__MINGW32__) 68 if (mBasePtr && UnmapViewOfFile(mBasePtr) == 0) { 69 ALOGD("UnmapViewOfFile(%p) failed, error = %" PRId32 "\n", mBasePtr, 70 GetLastError() ); 71 } 72 if (mFileMapping != INVALID_HANDLE_VALUE) { 73 CloseHandle(mFileMapping); 74 } 75#else 76 if (mBasePtr && munmap(mBasePtr, mBaseLength) != 0) { 77 ALOGD("munmap(%p, %zu) failed\n", mBasePtr, mBaseLength); 78 } 79#endif 80} 81 82 83// Create a new mapping on an open file. 84// 85// Closing the file descriptor does not unmap the pages, so we don't 86// claim ownership of the fd. 87// 88// Returns "false" on failure. 89bool FileMap::create(const char* origFileName, int fd, off64_t offset, size_t length, 90 bool readOnly) 91{ 92#if defined(__MINGW32__) 93 int adjust; 94 off64_t adjOffset; 95 size_t adjLength; 96 97 if (mPageSize == -1) { 98 SYSTEM_INFO si; 99 100 GetSystemInfo( &si ); 101 mPageSize = si.dwAllocationGranularity; 102 } 103 104 DWORD protect = readOnly ? PAGE_READONLY : PAGE_READWRITE; 105 106 mFileHandle = (HANDLE) _get_osfhandle(fd); 107 mFileMapping = CreateFileMapping( mFileHandle, NULL, protect, 0, 0, NULL); 108 if (mFileMapping == NULL) { 109 ALOGE("CreateFileMapping(%p, %" PRIx32 ") failed with error %" PRId32 "\n", 110 mFileHandle, protect, GetLastError() ); 111 return false; 112 } 113 114 adjust = offset % mPageSize; 115 adjOffset = offset - adjust; 116 adjLength = length + adjust; 117 118 mBasePtr = MapViewOfFile( mFileMapping, 119 readOnly ? FILE_MAP_READ : FILE_MAP_ALL_ACCESS, 120 0, 121 (DWORD)(adjOffset), 122 adjLength ); 123 if (mBasePtr == NULL) { 124 ALOGE("MapViewOfFile(%" PRId64 ", %zu) failed with error %" PRId32 "\n", 125 adjOffset, adjLength, GetLastError() ); 126 CloseHandle(mFileMapping); 127 mFileMapping = INVALID_HANDLE_VALUE; 128 return false; 129 } 130#else // !defined(__MINGW32__) 131 int prot, flags, adjust; 132 off64_t adjOffset; 133 size_t adjLength; 134 135 void* ptr; 136 137 assert(mRefCount == 1); 138 assert(fd >= 0); 139 assert(offset >= 0); 140 assert(length > 0); 141 142 // init on first use 143 if (mPageSize == -1) { 144#if NOT_USING_KLIBC 145 mPageSize = sysconf(_SC_PAGESIZE); 146 if (mPageSize == -1) { 147 ALOGE("could not get _SC_PAGESIZE\n"); 148 return false; 149 } 150#else 151 // this holds for Linux, Darwin, Cygwin, and doesn't pain the ARM 152 mPageSize = 4096; 153#endif 154 } 155 156 adjust = offset % mPageSize; 157try_again: 158 adjOffset = offset - adjust; 159 adjLength = length + adjust; 160 161 flags = MAP_SHARED; 162 prot = PROT_READ; 163 if (!readOnly) 164 prot |= PROT_WRITE; 165 166 ptr = mmap(NULL, adjLength, prot, flags, fd, adjOffset); 167 if (ptr == MAP_FAILED) { 168 // Cygwin does not seem to like file mapping files from an offset. 169 // So if we fail, try again with offset zero 170 if (adjOffset > 0) { 171 adjust = offset; 172 goto try_again; 173 } 174 175 ALOGE("mmap(%lld,%zu) failed: %s\n", 176 (long long)adjOffset, adjLength, strerror(errno)); 177 return false; 178 } 179 mBasePtr = ptr; 180#endif // !defined(__MINGW32__) 181 182 mFileName = origFileName != NULL ? strdup(origFileName) : NULL; 183 mBaseLength = adjLength; 184 mDataOffset = offset; 185 mDataPtr = (char*) mBasePtr + adjust; 186 mDataLength = length; 187 188 assert(mBasePtr != NULL); 189 190 ALOGV("MAP: base %p/%zu data %p/%zu\n", 191 mBasePtr, mBaseLength, mDataPtr, mDataLength); 192 193 return true; 194} 195 196// Provide guidance to the system. 197int FileMap::advise(MapAdvice advice) 198{ 199#if !defined(_WIN32) 200 int cc, sysAdvice; 201 202 switch (advice) { 203 case NORMAL: sysAdvice = MADV_NORMAL; break; 204 case RANDOM: sysAdvice = MADV_RANDOM; break; 205 case SEQUENTIAL: sysAdvice = MADV_SEQUENTIAL; break; 206 case WILLNEED: sysAdvice = MADV_WILLNEED; break; 207 case DONTNEED: sysAdvice = MADV_DONTNEED; break; 208 default: 209 assert(false); 210 return -1; 211 } 212 213 cc = madvise(mBasePtr, mBaseLength, sysAdvice); 214 if (cc != 0) 215 ALOGW("madvise(%d) failed: %s\n", sysAdvice, strerror(errno)); 216 return cc; 217#else 218 return -1; 219#endif 220} 221