| /* |
| * Copyright (C) 2017 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package android.util.apk; |
| |
| import android.system.ErrnoException; |
| import android.system.Os; |
| import android.system.OsConstants; |
| |
| import java.io.FileDescriptor; |
| import java.io.IOException; |
| import java.nio.ByteBuffer; |
| import java.nio.DirectByteBuffer; |
| import java.security.DigestException; |
| |
| /** |
| * {@link DataSource} which provides data from a file descriptor by memory-mapping the sections |
| * of the file. |
| */ |
| class MemoryMappedFileDataSource implements DataSource { |
| private static final long MEMORY_PAGE_SIZE_BYTES = Os.sysconf(OsConstants._SC_PAGESIZE); |
| |
| private final FileDescriptor mFd; |
| private final long mFilePosition; |
| private final long mSize; |
| |
| /** |
| * Constructs a new {@code MemoryMappedFileDataSource} for the specified region of the file. |
| * |
| * @param position start position of the region in the file. |
| * @param size size (in bytes) of the region. |
| */ |
| MemoryMappedFileDataSource(FileDescriptor fd, long position, long size) { |
| mFd = fd; |
| mFilePosition = position; |
| mSize = size; |
| } |
| |
| @Override |
| public long size() { |
| return mSize; |
| } |
| |
| @Override |
| public void feedIntoDataDigester(DataDigester md, long offset, int size) |
| throws IOException, DigestException { |
| // IMPLEMENTATION NOTE: After a lot of experimentation, the implementation of this |
| // method was settled on a straightforward mmap with prefaulting. |
| // |
| // This method is not using FileChannel.map API because that API does not offset a way |
| // to "prefault" the resulting memory pages. Without prefaulting, performance is about |
| // 10% slower on small to medium APKs, but is significantly worse for APKs in 500+ MB |
| // range. FileChannel.load (which currently uses madvise) doesn't help. Finally, |
| // invoking madvise (MADV_SEQUENTIAL) after mmap with prefaulting wastes quite a bit of |
| // time, which is not compensated for by faster reads. |
| |
| // We mmap the smallest region of the file containing the requested data. mmap requires |
| // that the start offset in the file must be a multiple of memory page size. We thus may |
| // need to mmap from an offset less than the requested offset. |
| long filePosition = mFilePosition + offset; |
| long mmapFilePosition = |
| (filePosition / MEMORY_PAGE_SIZE_BYTES) * MEMORY_PAGE_SIZE_BYTES; |
| int dataStartOffsetInMmapRegion = (int) (filePosition - mmapFilePosition); |
| long mmapRegionSize = size + dataStartOffsetInMmapRegion; |
| long mmapPtr = 0; |
| try { |
| mmapPtr = Os.mmap( |
| 0, // let the OS choose the start address of the region in memory |
| mmapRegionSize, |
| OsConstants.PROT_READ, |
| OsConstants.MAP_SHARED | OsConstants.MAP_POPULATE, // "prefault" all pages |
| mFd, |
| mmapFilePosition); |
| ByteBuffer buf = new DirectByteBuffer( |
| size, |
| mmapPtr + dataStartOffsetInMmapRegion, |
| mFd, // not really needed, but just in case |
| null, // no need to clean up -- it's taken care of by the finally block |
| true // read only buffer |
| ); |
| md.consume(buf); |
| } catch (ErrnoException e) { |
| throw new IOException("Failed to mmap " + mmapRegionSize + " bytes", e); |
| } finally { |
| if (mmapPtr != 0) { |
| try { |
| Os.munmap(mmapPtr, mmapRegionSize); |
| } catch (ErrnoException ignored) { } |
| } |
| } |
| } |
| } |