Merge "Create a FuseDataProvider base class" (4aa4bf5e) · Commits · e / os / android_bootable_recovery

Android.bp

+1 −1

Original line number	Diff line number	Diff line
		@@ -174,7 +174,7 @@ cc_library_static {
		srcs: [
		"adb_install.cpp",
		"fsck_unshare_blocks.cpp",
		"fuse_sdcard_provider.cpp",
		"fuse_sdcard_install.cpp",
		"install.cpp",
		"recovery.cpp",
		"roots.cpp",

fuse_sdcard_provider.cpp→fuse_sdcard_install.cpp

+45 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2014 The Android Open Source Project
		* Copyright (C) 2019 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.
		@@ -14,70 +14,32 @@
		* limitations under the License.
		*/

		#include "fuse_sdcard_provider.h"
		#include "fuse_sdcard_install.h"

		#include <errno.h>
		#include <fcntl.h>
		#include <stdio.h>
		#include <stdlib.h>
		#include <string.h>
		#include <sys/mount.h>
		#include <sys/stat.h>
		#include <unistd.h>

		#include <functional>

		#include <android-base/file.h>

		#include "fuse_provider.h"
		#include "fuse_sideload.h"

		struct file_data {
		int fd; // the underlying sdcard file

		uint64_t file_size;
		uint32_t block_size;
		};

		static int read_block_file(const file_data& fd, uint32_t block, uint8_t* buffer,
		uint32_t fetch_size) {
		off64_t offset = static_cast<off64_t>(block) * fd.block_size;
		if (TEMP_FAILURE_RETRY(lseek64(fd.fd, offset, SEEK_SET)) == -1) {
		fprintf(stderr, "seek on sdcard failed: %s\n", strerror(errno));
		return -EIO;
		}

		if (!android::base::ReadFully(fd.fd, buffer, fetch_size)) {
		fprintf(stderr, "read on sdcard failed: %s\n", strerror(errno));
		return -EIO;
		}

		return 0;
		}

		bool start_sdcard_fuse(const char* path) {
		struct stat sb;
		if (stat(path, &sb) == -1) {
		fprintf(stderr, "failed to stat %s: %s\n", path, strerror(errno));
		return false;
		}
		FuseFileDataProvider file_data_reader(path, 65536);

		file_data fd;
		fd.fd = open(path, O_RDONLY);
		if (fd.fd == -1) {
		fprintf(stderr, "failed to open %s: %s\n", path, strerror(errno));
		if (!file_data_reader) {
		return false;
		}
		fd.file_size = sb.st_size;
		fd.block_size = 65536;

		provider_vtab vtab;
		vtab.read_block = std::bind(&read_block_file, fd, std::placeholders::_1, std::placeholders::_2,
		std::placeholders::_3);
		vtab.close = [&fd]() { close(fd.fd); };
		vtab.read_block = std::bind(&FuseFileDataProvider::ReadBlockAlignedData, &file_data_reader,
		std::placeholders::_2, std::placeholders::_3, std::placeholders::_1);
		vtab.close = [&file_data_reader]() { file_data_reader.Close(); };

		// The installation process expects to find the sdcard unmounted. Unmount it with MNT_DETACH so
		// that our open file continues to work but new references see it as unmounted.
		umount2("/sdcard", MNT_DETACH);

		return run_fuse_sideload(vtab, fd.file_size, fd.block_size) == 0;
		return run_fuse_sideload(vtab, file_data_reader.file_size(),
		file_data_reader.fuse_block_size()) == 0;
		}

fuse_sdcard_provider.h→fuse_sdcard_install.h

+2 −5

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2014 The Android Open Source Project
		* Copyright (C) 2019 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.
		@@ -14,9 +14,6 @@
		* limitations under the License.
		*/

		#ifndef __FUSE_SDCARD_PROVIDER_H
		#define __FUSE_SDCARD_PROVIDER_H
		#pragma once

		bool start_sdcard_fuse(const char* path);

		#endif

fuse_sideload/Android.bp

+5 −2

Original line number	Diff line number	Diff line
		@@ -16,14 +16,17 @@ cc_library {
		name: "libfusesideload",
		recovery_available: true,

		defaults: [
		"recovery_defaults",
		],

		cflags: [
		"-D_XOPEN_SOURCE",
		"-D_GNU_SOURCE",
		"-Wall",
		"-Werror",
		],

		srcs: [
		"fuse_provider.cpp",
		"fuse_sideload.cpp",
		],

fuse_sideload/fuse_provider.cpp

0 → 100644

+71 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2019 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 "fuse_provider.h"

		#include <errno.h>
		#include <fcntl.h>
		#include <inttypes.h>
		#include <stdio.h>
		#include <string.h>
		#include <sys/stat.h>
		#include <unistd.h>

		#include <functional>

		#include <android-base/file.h>

		#include "fuse_sideload.h"

		FuseFileDataProvider::FuseFileDataProvider(const std::string& path, uint32_t block_size) {
		struct stat sb;
		if (stat(path.c_str(), &sb) == -1) {
		fprintf(stderr, "failed to stat %s: %s\n", path.c_str(), strerror(errno));
		return;
		}

		fd_.reset(open(path.c_str(), O_RDONLY));
		if (fd_ == -1) {
		fprintf(stderr, "failed to open %s: %s\n", path.c_str(), strerror(errno));
		return;
		}
		file_size_ = sb.st_size;
		fuse_block_size_ = block_size;
		}

		bool FuseFileDataProvider::ReadBlockAlignedData(uint8_t* buffer, uint32_t fetch_size,
		uint32_t start_block) const {
		uint64_t offset = static_cast<uint64_t>(start_block) * fuse_block_size_;
		if (fetch_size > file_size_ \|\| offset > file_size_ - fetch_size) {
		fprintf(stderr,
		"Out of bound read, start block: %" PRIu32 ", fetch size: %" PRIu32
		", file size %" PRIu64 "\n",
		start_block, fetch_size, file_size_);
		return false;
		}

		if (!android::base::ReadFullyAtOffset(fd_, buffer, fetch_size, offset)) {
		fprintf(stderr, "Failed to read fetch size: %" PRIu32 " bytes data at offset %" PRIu64 ": %s\n",
		fetch_size, offset, strerror(errno));
		return false;
		}

		return true;
		}

		void FuseFileDataProvider::Close() {
		fd_.reset();
		}