Merge "Add a simple MappedFile to libbase and switch fastboot and libziparchive over." (15611963) · Commits · e / os / android_system_core

base/Android.bp

+2 −0

Original line number	Diff line number	Diff line
		@@ -47,6 +47,7 @@ cc_defaults {
		"chrono_utils.cpp",
		"file.cpp",
		"logging.cpp",
		"mapped_file.cpp",
		"parsenetaddress.cpp",
		"properties.cpp",
		"quick_exit.cpp",
		@@ -124,6 +125,7 @@ cc_test {
		"file_test.cpp",
		"logging_test.cpp",
		"macros_test.cpp",
		"mapped_file_test.cpp",
		"parsedouble_test.cpp",
		"parseint_test.cpp",
		"parsenetaddress_test.cpp",

base/include/android-base/mapped_file.h

0 → 100644

+74 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2018 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.
		*/

		#pragma once

		#include "android-base/macros.h"

		#include <sys/types.h>

		#include <memory>

		#if defined(_WIN32)
		#include <windows.h>
		#define PROT_READ 1
		#define PROT_WRITE 2
		#else
		#include <sys/mman.h>
		#endif

		namespace android {
		namespace base {

		/**
		* A region of a file mapped into memory.
		*/
		class MappedFile {
		public:
		/**
		* Creates a new mapping of the file pointed to by `fd`. Unlike the underlying OS primitives,
		* `offset` does not need to be page-aligned. If `PROT_WRITE` is set in `prot`, the mapping
		* will be writable, otherwise it will be read-only. Mappings are always `MAP_SHARED`.
		*/
		static std::unique_ptr<MappedFile> FromFd(int fd, off64_t offset, size_t length, int prot);

		/**
		* Removes the mapping.
		*/
		~MappedFile();

		char* data() { return base_ + offset_; }
		size_t size() { return size_; }

		private:
		DISALLOW_IMPLICIT_CONSTRUCTORS(MappedFile);

		char* base_;
		size_t size_;

		size_t offset_;

		#if defined(_WIN32)
		MappedFile(char* base, size_t size, size_t offset, HANDLE handle)
		: base_(base), size_(size), offset_(offset), handle_(handle) {}
		HANDLE handle_;
		#else
		MappedFile(char* base, size_t size, size_t offset) : base_(base), size_(size), offset_(offset) {}
		#endif
		};

		} // namespace base
		} // namespace android

base/mapped_file.cpp

0 → 100644

+71 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2018 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.
		*/

		#include "android-base/mapped_file.h"

		namespace android {
		namespace base {

		static off64_t InitPageSize() {
		#if defined(_WIN32)
		SYSTEM_INFO si;
		GetSystemInfo(&si);
		return si.dwAllocationGranularity;
		#else
		return sysconf(_SC_PAGE_SIZE);
		#endif
		}

		std::unique_ptr<MappedFile> MappedFile::FromFd(int fd, off64_t offset, size_t length, int prot) {
		static off64_t page_size = InitPageSize();
		size_t slop = offset % page_size;
		off64_t file_offset = offset - slop;
		off64_t file_length = length + slop;

		#if defined(_WIN32)
		HANDLE handle =
		CreateFileMapping(reinterpret_cast<HANDLE>(_get_osfhandle(fd)), nullptr,
		(prot & PROT_WRITE) ? PAGE_READWRITE : PAGE_READONLY, 0, 0, nullptr);
		if (handle == nullptr) return nullptr;
		void* base = MapViewOfFile(handle, (prot & PROT_WRITE) ? FILE_MAP_ALL_ACCESS : FILE_MAP_READ, 0,
		file_offset, file_length);
		if (base == nullptr) {
		CloseHandle(handle);
		return nullptr;
		}
		return std::unique_ptr<MappedFile>(
		new MappedFile{static_cast<char*>(base), length, slop, handle});
		#else
		void* base = mmap(nullptr, file_length, prot, MAP_SHARED, fd, file_offset);
		if (base == MAP_FAILED) return nullptr;
		return std::unique_ptr<MappedFile>(new MappedFile{static_cast<char*>(base), length, slop});
		#endif
		}

		MappedFile::~MappedFile() {
		#if defined(_WIN32)
		if (base_ != nullptr) UnmapViewOfFile(base_);
		if (handle_ != nullptr) CloseHandle(handle_);
		#else
		if (base_ != nullptr) munmap(base_, size_);
		#endif

		base_ = nullptr;
		offset_ = size_ = 0;
		}

		} // namespace base
		} // namespace android

base/mapped_file_test.cpp

0 → 100644

+40 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2018 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.
		*/

		#include "android-base/mapped_file.h"

		#include <gtest/gtest.h>

		#include <errno.h>
		#include <fcntl.h>
		#include <unistd.h>

		#include <string>

		#include "android-base/file.h"
		#include "android-base/test_utils.h"
		#include "android-base/unique_fd.h"

		TEST(mapped_file, smoke) {
		TemporaryFile tf;
		ASSERT_TRUE(tf.fd != -1);
		ASSERT_TRUE(android::base::WriteStringToFd("hello world", tf.fd));

		auto m = android::base::MappedFile::FromFd(tf.fd, 3, 2, PROT_READ);
		ASSERT_EQ(2u, m->size());
		ASSERT_EQ('l', m->data()[0]);
		ASSERT_EQ('o', m->data()[1]);
		}

fastboot/fastboot.cpp

+2 −2

Original line number	Diff line number	Diff line
		@@ -79,8 +79,8 @@ using android::base::Split;
		using android::base::Trim;
		using android::base::unique_fd;

		#ifndef O_BINARY
		#define O_BINARY 0
		#if defined(_WIN32)
		#define O_CLOEXEC O_NOINHERIT
		#endif

		static const char* serial = nullptr;