Remove the provider_vtab
It's no longer needed with the newly added FuseDataProvider class. Also
cleans up the parameters for run_fuse_sideload.
Bug: 127071893
Test: unit tests pass, run a sideload
Change-Id: I1ccd6798d187cfc6ac9f559ffb3f3edf08dad55c
diff --git a/fuse_sdcard_install.cpp b/fuse_sdcard_install.cpp
index 79ef16b..2feb4d2 100644
--- a/fuse_sdcard_install.cpp
+++ b/fuse_sdcard_install.cpp
@@ -20,26 +20,21 @@
#include <unistd.h>
#include <functional>
+#include <memory>
#include "fuse_provider.h"
#include "fuse_sideload.h"
bool start_sdcard_fuse(const char* path) {
- FuseFileDataProvider file_data_reader(path, 65536);
+ auto file_data_reader = std::make_unique<FuseFileDataProvider>(path, 65536);
- if (!file_data_reader) {
+ if (!file_data_reader->Valid()) {
return false;
}
- provider_vtab vtab;
- 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, file_data_reader.file_size(),
- file_data_reader.fuse_block_size()) == 0;
+ return run_fuse_sideload(std::move(file_data_reader)) == 0;
}
diff --git a/fuse_sideload/fuse_sideload.cpp b/fuse_sideload/fuse_sideload.cpp
index e812486..b5b6ac1 100644
--- a/fuse_sideload/fuse_sideload.cpp
+++ b/fuse_sideload/fuse_sideload.cpp
@@ -76,7 +76,7 @@
struct fuse_data {
android::base::unique_fd ffd; // file descriptor for the fuse socket
- provider_vtab vtab;
+ FuseDataProvider* provider; // Provider of the source data.
uint64_t file_size; // bytes
@@ -236,7 +236,7 @@
return 0;
}
- size_t fetch_size = fd->block_size;
+ uint32_t fetch_size = fd->block_size;
if (block * fd->block_size + fetch_size > fd->file_size) {
// If we're reading the last (partial) block of the file, expect a shorter response from the
// host, and pad the rest of the block with zeroes.
@@ -244,7 +244,7 @@
memset(fd->block_data + fetch_size, 0, fd->block_size - fetch_size);
}
- if (!fd->vtab.read_block(block, fd->block_data, fetch_size)) {
+ if (!fd->provider->ReadBlockAlignedData(fd->block_data, fetch_size, block)) {
return -EIO;
}
@@ -341,12 +341,14 @@
return NO_STATUS;
}
-int run_fuse_sideload(const provider_vtab& vtab, uint64_t file_size, uint32_t block_size,
- const char* mount_point) {
+int run_fuse_sideload(std::unique_ptr<FuseDataProvider>&& provider, const char* mount_point) {
// If something's already mounted on our mountpoint, try to remove it. (Mostly in case of a
// previous abnormal exit.)
umount2(mount_point, MNT_FORCE);
+ uint64_t file_size = provider->file_size();
+ uint32_t block_size = provider->fuse_block_size();
+
// fs/fuse/inode.c in kernel code uses the greater of 4096 and the passed-in max_read.
if (block_size < 4096) {
fprintf(stderr, "block size (%u) is too small\n", block_size);
@@ -358,7 +360,7 @@
}
fuse_data fd = {};
- fd.vtab = vtab;
+ fd.provider = provider.get();
fd.file_size = file_size;
fd.block_size = block_size;
fd.file_blocks = (file_size == 0) ? 0 : (((file_size - 1) / block_size) + 1);
@@ -480,7 +482,7 @@
}
done:
- fd.vtab.close();
+ provider->Close();
if (umount2(mount_point, MNT_DETACH) == -1) {
fprintf(stderr, "fuse_sideload umount failed: %s\n", strerror(errno));
diff --git a/fuse_sideload/include/fuse_provider.h b/fuse_sideload/include/fuse_provider.h
index 672af05..499d57a 100644
--- a/fuse_sideload/include/fuse_provider.h
+++ b/fuse_sideload/include/fuse_provider.h
@@ -37,7 +37,7 @@
return fuse_block_size_;
}
- explicit operator bool() const {
+ bool Valid() const {
return fd_ != -1;
}
diff --git a/fuse_sideload/include/fuse_sideload.h b/fuse_sideload/include/fuse_sideload.h
index 821c7c8..1b7759a 100644
--- a/fuse_sideload/include/fuse_sideload.h
+++ b/fuse_sideload/include/fuse_sideload.h
@@ -17,7 +17,9 @@
#ifndef __FUSE_SIDELOAD_H
#define __FUSE_SIDELOAD_H
-#include <functional>
+#include <memory>
+
+#include "fuse_provider.h"
// Define the filenames created by the sideload FUSE filesystem.
static constexpr const char* FUSE_SIDELOAD_HOST_MOUNTPOINT = "/sideload";
@@ -26,15 +28,7 @@
static constexpr const char* FUSE_SIDELOAD_HOST_EXIT_FLAG = "exit";
static constexpr const char* FUSE_SIDELOAD_HOST_EXIT_PATHNAME = "/sideload/exit";
-struct provider_vtab {
- // read a block
- std::function<bool(uint32_t block, uint8_t* buffer, uint32_t fetch_size)> read_block;
-
- // close down
- std::function<void(void)> close;
-};
-
-int run_fuse_sideload(const provider_vtab& vtab, uint64_t file_size, uint32_t block_size,
+int run_fuse_sideload(std::unique_ptr<FuseDataProvider>&& provider,
const char* mount_point = FUSE_SIDELOAD_HOST_MOUNTPOINT);
#endif
diff --git a/minadbd/fuse_adb_provider.cpp b/minadbd/fuse_adb_provider.cpp
index cada4bd..9d19a1e 100644
--- a/minadbd/fuse_adb_provider.cpp
+++ b/minadbd/fuse_adb_provider.cpp
@@ -18,14 +18,10 @@
#include <errno.h>
#include <stdio.h>
-#include <stdlib.h>
#include <string.h>
-#include <functional>
-
#include "adb.h"
#include "adb_io.h"
-#include "fuse_sideload.h"
bool FuseAdbDataProvider::ReadBlockAlignedData(uint8_t* buffer, uint32_t fetch_size,
uint32_t start_block) const {
@@ -45,14 +41,3 @@
void FuseAdbDataProvider::Close() {
WriteFdExactly(fd_, "DONEDONE");
}
-
-int run_adb_fuse(android::base::unique_fd&& sfd, uint64_t file_size, uint32_t block_size) {
- FuseAdbDataProvider adb_data_reader(std::move(sfd), file_size, block_size);
-
- provider_vtab vtab;
- vtab.read_block = std::bind(&FuseAdbDataProvider::ReadBlockAlignedData, &adb_data_reader,
- std::placeholders::_2, std::placeholders::_3, std::placeholders::_1);
- vtab.close = [&adb_data_reader]() { adb_data_reader.Close(); };
-
- return run_fuse_sideload(vtab, file_size, block_size);
-}
diff --git a/minadbd/fuse_adb_provider.h b/minadbd/fuse_adb_provider.h
index e93aa04..3fb689b 100644
--- a/minadbd/fuse_adb_provider.h
+++ b/minadbd/fuse_adb_provider.h
@@ -35,6 +35,4 @@
void Close() override;
};
-int run_adb_fuse(android::base::unique_fd&& sfd, uint64_t file_size, uint32_t block_size);
-
#endif
diff --git a/minadbd/minadbd_services.cpp b/minadbd/minadbd_services.cpp
index 3e11285..6fe5c79 100644
--- a/minadbd/minadbd_services.cpp
+++ b/minadbd/minadbd_services.cpp
@@ -22,6 +22,7 @@
#include <unistd.h>
#include <functional>
+#include <memory>
#include <string>
#include <string_view>
#include <thread>
@@ -30,6 +31,7 @@
#include "adb_unique_fd.h"
#include "fdevent.h"
#include "fuse_adb_provider.h"
+#include "fuse_sideload.h"
#include "services.h"
#include "sysdeps.h"
@@ -44,7 +46,9 @@
printf("sideload-host file size %" PRId64 " block size %d\n", file_size, block_size);
- int result = run_adb_fuse(std::move(sfd), file_size, block_size);
+ auto adb_data_reader =
+ std::make_unique<FuseAdbDataProvider>(std::move(sfd), file_size, block_size);
+ int result = run_fuse_sideload(std::move(adb_data_reader));
printf("sideload_host finished\n");
exit(result == 0 ? 0 : 1);
diff --git a/tests/component/sideload_test.cpp b/tests/component/sideload_test.cpp
index 8d290db..f5981ac 100644
--- a/tests/component/sideload_test.cpp
+++ b/tests/component/sideload_test.cpp
@@ -16,13 +16,16 @@
#include <unistd.h>
+#include <memory>
#include <string>
#include <vector>
#include <android-base/file.h>
#include <android-base/strings.h>
+#include <android-base/unique_fd.h>
#include <gtest/gtest.h>
+#include "fuse_provider.h"
#include "fuse_sideload.h"
TEST(SideloadTest, fuse_device) {
@@ -30,14 +33,17 @@
}
TEST(SideloadTest, run_fuse_sideload_wrong_parameters) {
- provider_vtab vtab;
- vtab.close = [](void) {};
+ auto provider_small_block =
+ std::make_unique<FuseFileDataProvider>(android::base::unique_fd(), 4096, 4095);
+ ASSERT_EQ(-1, run_fuse_sideload(std::move(provider_small_block)));
- ASSERT_EQ(-1, run_fuse_sideload(vtab, 4096, 4095));
- ASSERT_EQ(-1, run_fuse_sideload(vtab, 4096, (1 << 22) + 1));
+ auto provider_large_block =
+ std::make_unique<FuseFileDataProvider>(android::base::unique_fd(), 4096, (1 << 22) + 1);
+ ASSERT_EQ(-1, run_fuse_sideload(std::move(provider_large_block)));
- // Too many blocks.
- ASSERT_EQ(-1, run_fuse_sideload(vtab, ((1 << 18) + 1) * 4096, 4096));
+ auto provider_too_many_blocks = std::make_unique<FuseFileDataProvider>(
+ android::base::unique_fd(), ((1 << 18) + 1) * 4096, 4096);
+ ASSERT_EQ(-1, run_fuse_sideload(std::move(provider_too_many_blocks)));
}
TEST(SideloadTest, run_fuse_sideload) {
@@ -50,18 +56,15 @@
const std::string content = android::base::Join(blocks, "");
ASSERT_EQ(16384U, content.size());
- provider_vtab vtab;
- vtab.close = [](void) {};
- vtab.read_block = [&blocks](uint32_t block, uint8_t* buffer, uint32_t fetch_size) {
- if (block >= 4) return false;
- blocks[block].copy(reinterpret_cast<char*>(buffer), fetch_size);
- return true;
- };
+ TemporaryFile temp_file;
+ ASSERT_TRUE(android::base::WriteStringToFile(content, temp_file.path));
+ auto provider = std::make_unique<FuseFileDataProvider>(temp_file.path, 4096);
+ ASSERT_TRUE(provider->Valid());
TemporaryDir mount_point;
pid_t pid = fork();
if (pid == 0) {
- ASSERT_EQ(0, run_fuse_sideload(vtab, 16384, 4096, mount_point.path));
+ ASSERT_EQ(0, run_fuse_sideload(std::move(provider), mount_point.path));
_exit(EXIT_SUCCESS);
}