Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit ea2912f1 authored by xunchang's avatar xunchang
Browse files

Create a FuseDataProvider base class 

The fuse data provider for adb/sdcard shares common code and structures.
This cl creates a FuseDataProvider base class and provides
implementations for adb and sdcard.

In the follow cls, we can kill the provider_vtab struct; and also add
another implementation to parse a block map file and provides data.

Test: unit tests pass, sideload a package, apply a package from sdcard
Change-Id: If8311666a52a2e3c0fbae0ee9688fa6d01e4ad09
parent 698dc085

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();

}