diff options
Diffstat (limited to 'otafault')
| -rw-r--r-- | otafault/Android.bp | 68 | ||||
| -rw-r--r-- | otafault/config.cpp | 75 | ||||
| -rw-r--r-- | otafault/include/otafault/config.h | 72 | ||||
| -rw-r--r-- | otafault/include/otafault/ota_io.h | 70 | ||||
| -rw-r--r-- | otafault/ota_io.cpp | 212 | ||||
| -rw-r--r-- | otafault/test.cpp | 35 |
6 files changed, 0 insertions, 532 deletions
diff --git a/otafault/Android.bp b/otafault/Android.bp deleted file mode 100644 index b39d5bee2..000000000 --- a/otafault/Android.bp +++ /dev/null @@ -1,68 +0,0 @@ -// 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. - -cc_library_static { - name: "libotafault", - - host_supported: true, - - srcs: [ - "config.cpp", - "ota_io.cpp", - ], - - static_libs: [ - "libbase", - "liblog", - "libziparchive", - ], - - export_include_dirs: [ - "include", - ], - - cflags: [ - "-D_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS", - "-Wall", - "-Werror", - "-Wthread-safety", - "-Wthread-safety-negative", - ], - - target: { - darwin: { - enabled: false, - }, - }, -} - -cc_test { - name: "otafault_test", - - srcs: ["test.cpp"], - - cflags: [ - "-Wall", - "-Werror", - ], - - static_executable: true, - - static_libs: [ - "libotafault", - "libziparchive", - "libbase", - "liblog", - ], -} diff --git a/otafault/config.cpp b/otafault/config.cpp deleted file mode 100644 index 3993948ff..000000000 --- a/otafault/config.cpp +++ /dev/null @@ -1,75 +0,0 @@ -/* - * Copyright (C) 2015 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 "otafault/config.h" - -#include <map> -#include <string> - -#include <android-base/stringprintf.h> -#include <ziparchive/zip_archive.h> - -#include "otafault/ota_io.h" - -#define OTAIO_MAX_FNAME_SIZE 128 - -static ZipArchiveHandle archive; -static bool is_retry = false; -static std::map<std::string, bool> should_inject_cache; - -static std::string get_type_path(const char* io_type) { - return android::base::StringPrintf("%s/%s", OTAIO_BASE_DIR, io_type); -} - -void ota_io_init(ZipArchiveHandle za, bool retry) { - archive = za; - is_retry = retry; - ota_set_fault_files(); -} - -bool should_fault_inject(const char* io_type) { - // archive will be NULL if we used an entry point other - // than updater/updater.cpp:main - if (archive == nullptr || is_retry) { - return false; - } - const std::string type_path = get_type_path(io_type); - if (should_inject_cache.find(type_path) != should_inject_cache.end()) { - return should_inject_cache[type_path]; - } - ZipString zip_type_path(type_path.c_str()); - ZipEntry entry; - int status = FindEntry(archive, zip_type_path, &entry); - should_inject_cache[type_path] = (status == 0); - return (status == 0); -} - -bool should_hit_cache() { - return should_fault_inject(OTAIO_CACHE); -} - -std::string fault_fname(const char* io_type) { - std::string type_path = get_type_path(io_type); - std::string fname; - fname.resize(OTAIO_MAX_FNAME_SIZE); - ZipString zip_type_path(type_path.c_str()); - ZipEntry entry; - if (FindEntry(archive, zip_type_path, &entry) != 0) { - return {}; - } - ExtractToMemory(archive, &entry, reinterpret_cast<uint8_t*>(&fname[0]), OTAIO_MAX_FNAME_SIZE); - return fname; -} diff --git a/otafault/include/otafault/config.h b/otafault/include/otafault/config.h deleted file mode 100644 index cc4bfd2ad..000000000 --- a/otafault/include/otafault/config.h +++ /dev/null @@ -1,72 +0,0 @@ -/* - * Copyright (C) 2015 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. - */ - -/* - * Read configuration files in the OTA package to determine which files, if any, will trigger - * errors. - * - * OTA packages can be modified to trigger errors by adding a top-level directory called - * .libotafault, which may optionally contain up to three files called READ, WRITE, and FSYNC. - * Each one of these optional files contains the name of a single file on the device disk which - * will cause an IO error on the first call of the appropriate I/O action to that file. - * - * Example: - * ota.zip - * <normal package contents> - * .libotafault - * WRITE - * - * If the contents of the file WRITE were /system/build.prop, the first write action to - * /system/build.prop would fail with EIO. Note that READ and FSYNC files are absent, so these - * actions will not cause an error. - */ - -#ifndef _UPDATER_OTA_IO_CFG_H_ -#define _UPDATER_OTA_IO_CFG_H_ - -#include <string> - -#include <ziparchive/zip_archive.h> - -#define OTAIO_BASE_DIR ".libotafault" -#define OTAIO_READ "READ" -#define OTAIO_WRITE "WRITE" -#define OTAIO_FSYNC "FSYNC" -#define OTAIO_CACHE "CACHE" - -/* - * Initialize libotafault by providing a reference to the OTA package. - */ -void ota_io_init(ZipArchiveHandle zip, bool retry); - -/* - * Return true if a config file is present for the given IO type. - */ -bool should_fault_inject(const char* io_type); - -/* - * Return true if an EIO should occur on the next hit to /cache/saved.file - * instead of the next hit to the specified file. - */ -bool should_hit_cache(); - -/* - * Return the name of the file that should cause an error for the - * given IO type. - */ -std::string fault_fname(const char* io_type); - -#endif diff --git a/otafault/include/otafault/ota_io.h b/otafault/include/otafault/ota_io.h deleted file mode 100644 index 45e481a62..000000000 --- a/otafault/include/otafault/ota_io.h +++ /dev/null @@ -1,70 +0,0 @@ -/* - * Copyright (C) 2015 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. - */ - -/* - * Provide a series of proxy functions for basic file accessors. - * The behavior of these functions can be changed to return different - * errors under a variety of conditions. - */ - -#ifndef _UPDATER_OTA_IO_H_ -#define _UPDATER_OTA_IO_H_ - -#include <stddef.h> -#include <stdio.h> -#include <sys/stat.h> // mode_t - -#include <memory> - -#include <android-base/unique_fd.h> - -#define OTAIO_CACHE_FNAME "/cache/saved.file" - -void ota_set_fault_files(); - -int ota_open(const char* path, int oflags); - -int ota_open(const char* path, int oflags, mode_t mode); - -FILE* ota_fopen(const char* filename, const char* mode); - -size_t ota_fread(void* ptr, size_t size, size_t nitems, FILE* stream); - -ssize_t ota_read(int fd, void* buf, size_t nbyte); - -size_t ota_fwrite(const void* ptr, size_t size, size_t count, FILE* stream); - -ssize_t ota_write(int fd, const void* buf, size_t nbyte); - -int ota_fsync(int fd); - -struct OtaCloser { - static void Close(int); -}; - -using unique_fd = android::base::unique_fd_impl<OtaCloser>; - -int ota_close(unique_fd& fd); - -struct OtaFcloser { - void operator()(FILE*) const; -}; - -using unique_file = std::unique_ptr<FILE, OtaFcloser>; - -int ota_fclose(unique_file& fh); - -#endif diff --git a/otafault/ota_io.cpp b/otafault/ota_io.cpp deleted file mode 100644 index 63ef18e26..000000000 --- a/otafault/ota_io.cpp +++ /dev/null @@ -1,212 +0,0 @@ -/* - * Copyright (C) 2015 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 "otafault/ota_io.h" - -#include <errno.h> -#include <fcntl.h> -#include <stdint.h> -#include <stdio.h> -#include <sys/stat.h> -#include <sys/types.h> -#include <unistd.h> - -#include <map> -#include <mutex> -#include <string> - -#include <android-base/thread_annotations.h> - -#include "otafault/config.h" - -static std::mutex filename_mutex; -static std::map<intptr_t, const char*> filename_cache GUARDED_BY(filename_mutex); -static std::string read_fault_file_name = ""; -static std::string write_fault_file_name = ""; -static std::string fsync_fault_file_name = ""; - -static bool get_hit_file(const char* cached_path, const std::string& ffn) { - return should_hit_cache() - ? !strncmp(cached_path, OTAIO_CACHE_FNAME, strlen(cached_path)) - : !strncmp(cached_path, ffn.c_str(), strlen(cached_path)); -} - -void ota_set_fault_files() { - if (should_fault_inject(OTAIO_READ)) { - read_fault_file_name = fault_fname(OTAIO_READ); - } - if (should_fault_inject(OTAIO_WRITE)) { - write_fault_file_name = fault_fname(OTAIO_WRITE); - } - if (should_fault_inject(OTAIO_FSYNC)) { - fsync_fault_file_name = fault_fname(OTAIO_FSYNC); - } -} - -bool have_eio_error = false; - -int ota_open(const char* path, int oflags) { - // Let the caller handle errors; we do not care if open succeeds or fails - int fd = open(path, oflags); - std::lock_guard<std::mutex> lock(filename_mutex); - filename_cache[fd] = path; - return fd; -} - -int ota_open(const char* path, int oflags, mode_t mode) { - int fd = open(path, oflags, mode); - std::lock_guard<std::mutex> lock(filename_mutex); - filename_cache[fd] = path; - return fd; -} - -FILE* ota_fopen(const char* path, const char* mode) { - FILE* fh = fopen(path, mode); - std::lock_guard<std::mutex> lock(filename_mutex); - filename_cache[(intptr_t)fh] = path; - return fh; -} - -static int __ota_close(int fd) { - // descriptors can be reused, so make sure not to leave them in the cache - std::lock_guard<std::mutex> lock(filename_mutex); - filename_cache.erase(fd); - return close(fd); -} - -void OtaCloser::Close(int fd) { - __ota_close(fd); -} - -int ota_close(unique_fd& fd) { - return __ota_close(fd.release()); -} - -static int __ota_fclose(FILE* fh) { - std::lock_guard<std::mutex> lock(filename_mutex); - filename_cache.erase(reinterpret_cast<intptr_t>(fh)); - return fclose(fh); -} - -void OtaFcloser::operator()(FILE* f) const { - __ota_fclose(f); -}; - -int ota_fclose(unique_file& fh) { - return __ota_fclose(fh.release()); -} - -size_t ota_fread(void* ptr, size_t size, size_t nitems, FILE* stream) { - if (should_fault_inject(OTAIO_READ)) { - std::lock_guard<std::mutex> lock(filename_mutex); - auto cached = filename_cache.find((intptr_t)stream); - const char* cached_path = cached->second; - if (cached != filename_cache.end() && - get_hit_file(cached_path, read_fault_file_name)) { - read_fault_file_name = ""; - errno = EIO; - have_eio_error = true; - return 0; - } - } - size_t status = fread(ptr, size, nitems, stream); - // If I/O error occurs, set the retry-update flag. - if (status != nitems && errno == EIO) { - have_eio_error = true; - } - return status; -} - -ssize_t ota_read(int fd, void* buf, size_t nbyte) { - if (should_fault_inject(OTAIO_READ)) { - std::lock_guard<std::mutex> lock(filename_mutex); - auto cached = filename_cache.find(fd); - const char* cached_path = cached->second; - if (cached != filename_cache.end() - && get_hit_file(cached_path, read_fault_file_name)) { - read_fault_file_name = ""; - errno = EIO; - have_eio_error = true; - return -1; - } - } - ssize_t status = read(fd, buf, nbyte); - if (status == -1 && errno == EIO) { - have_eio_error = true; - } - return status; -} - -size_t ota_fwrite(const void* ptr, size_t size, size_t count, FILE* stream) { - if (should_fault_inject(OTAIO_WRITE)) { - std::lock_guard<std::mutex> lock(filename_mutex); - auto cached = filename_cache.find((intptr_t)stream); - const char* cached_path = cached->second; - if (cached != filename_cache.end() && - get_hit_file(cached_path, write_fault_file_name)) { - write_fault_file_name = ""; - errno = EIO; - have_eio_error = true; - return 0; - } - } - size_t status = fwrite(ptr, size, count, stream); - if (status != count && errno == EIO) { - have_eio_error = true; - } - return status; -} - -ssize_t ota_write(int fd, const void* buf, size_t nbyte) { - if (should_fault_inject(OTAIO_WRITE)) { - std::lock_guard<std::mutex> lock(filename_mutex); - auto cached = filename_cache.find(fd); - const char* cached_path = cached->second; - if (cached != filename_cache.end() && - get_hit_file(cached_path, write_fault_file_name)) { - write_fault_file_name = ""; - errno = EIO; - have_eio_error = true; - return -1; - } - } - ssize_t status = write(fd, buf, nbyte); - if (status == -1 && errno == EIO) { - have_eio_error = true; - } - return status; -} - -int ota_fsync(int fd) { - if (should_fault_inject(OTAIO_FSYNC)) { - std::lock_guard<std::mutex> lock(filename_mutex); - auto cached = filename_cache.find(fd); - const char* cached_path = cached->second; - if (cached != filename_cache.end() && - get_hit_file(cached_path, fsync_fault_file_name)) { - fsync_fault_file_name = ""; - errno = EIO; - have_eio_error = true; - return -1; - } - } - int status = fsync(fd); - if (status == -1 && errno == EIO) { - have_eio_error = true; - } - return status; -} - diff --git a/otafault/test.cpp b/otafault/test.cpp deleted file mode 100644 index 63e2445af..000000000 --- a/otafault/test.cpp +++ /dev/null @@ -1,35 +0,0 @@ -/* - * Copyright (C) 2015 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 <fcntl.h> -#include <stdio.h> -#include <sys/stat.h> -#include <sys/types.h> -#include <unistd.h> - -#include "otafault/ota_io.h" - -int main(int /* argc */, char** /* argv */) { - int fd = open("testdata/test.file", O_RDWR); - char buf[8]; - const char* out = "321"; - int readv = ota_read(fd, buf, 4); - printf("Read returned %d\n", readv); - int writev = ota_write(fd, out, 4); - printf("Write returned %d\n", writev); - close(fd); - return 0; -} |