1 /* 2 * Copyright (C) 2015 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include <map> 18 19 #include <errno.h> 20 #include <fcntl.h> 21 #include <stdio.h> 22 #include <sys/stat.h> 23 #include <unistd.h> 24 25 #include "config.h" 26 #include "ota_io.h" 27 28 static std::map<intptr_t, const char*> filename_cache; 29 static std::string read_fault_file_name = ""; 30 static std::string write_fault_file_name = ""; 31 static std::string fsync_fault_file_name = ""; 32 33 static bool get_hit_file(const char* cached_path, std::string ffn) { 34 return should_hit_cache() 35 ? !strncmp(cached_path, OTAIO_CACHE_FNAME, strlen(cached_path)) 36 : !strncmp(cached_path, ffn.c_str(), strlen(cached_path)); 37 } 38 39 void ota_set_fault_files() { 40 if (should_fault_inject(OTAIO_READ)) { 41 read_fault_file_name = fault_fname(OTAIO_READ); 42 } 43 if (should_fault_inject(OTAIO_WRITE)) { 44 write_fault_file_name = fault_fname(OTAIO_WRITE); 45 } 46 if (should_fault_inject(OTAIO_FSYNC)) { 47 fsync_fault_file_name = fault_fname(OTAIO_FSYNC); 48 } 49 } 50 51 bool have_eio_error = false; 52 53 int ota_open(const char* path, int oflags) { 54 // Let the caller handle errors; we do not care if open succeeds or fails 55 int fd = open(path, oflags); 56 filename_cache[fd] = path; 57 return fd; 58 } 59 60 int ota_open(const char* path, int oflags, mode_t mode) { 61 int fd = open(path, oflags, mode); 62 filename_cache[fd] = path; 63 return fd; } 64 65 FILE* ota_fopen(const char* path, const char* mode) { 66 FILE* fh = fopen(path, mode); 67 filename_cache[(intptr_t)fh] = path; 68 return fh; 69 } 70 71 int ota_close(int fd) { 72 // descriptors can be reused, so make sure not to leave them in the cache 73 filename_cache.erase(fd); 74 return close(fd); 75 } 76 77 int ota_fclose(FILE* fh) { 78 filename_cache.erase((intptr_t)fh); 79 return fclose(fh); 80 } 81 82 size_t ota_fread(void* ptr, size_t size, size_t nitems, FILE* stream) { 83 if (should_fault_inject(OTAIO_READ)) { 84 auto cached = filename_cache.find((intptr_t)stream); 85 const char* cached_path = cached->second; 86 if (cached != filename_cache.end() && 87 get_hit_file(cached_path, read_fault_file_name)) { 88 read_fault_file_name = ""; 89 errno = EIO; 90 have_eio_error = true; 91 return 0; 92 } 93 } 94 size_t status = fread(ptr, size, nitems, stream); 95 if (status != nitems && errno == EIO) { 96 have_eio_error = true; 97 } 98 return status; 99 } 100 101 ssize_t ota_read(int fd, void* buf, size_t nbyte) { 102 if (should_fault_inject(OTAIO_READ)) { 103 auto cached = filename_cache.find(fd); 104 const char* cached_path = cached->second; 105 if (cached != filename_cache.end() 106 && get_hit_file(cached_path, read_fault_file_name)) { 107 read_fault_file_name = ""; 108 errno = EIO; 109 have_eio_error = true; 110 return -1; 111 } 112 } 113 ssize_t status = read(fd, buf, nbyte); 114 if (status == -1 && errno == EIO) { 115 have_eio_error = true; 116 } 117 return status; 118 } 119 120 size_t ota_fwrite(const void* ptr, size_t size, size_t count, FILE* stream) { 121 if (should_fault_inject(OTAIO_WRITE)) { 122 auto cached = filename_cache.find((intptr_t)stream); 123 const char* cached_path = cached->second; 124 if (cached != filename_cache.end() && 125 get_hit_file(cached_path, write_fault_file_name)) { 126 write_fault_file_name = ""; 127 errno = EIO; 128 have_eio_error = true; 129 return 0; 130 } 131 } 132 size_t status = fwrite(ptr, size, count, stream); 133 if (status != count && errno == EIO) { 134 have_eio_error = true; 135 } 136 return status; 137 } 138 139 ssize_t ota_write(int fd, const void* buf, size_t nbyte) { 140 if (should_fault_inject(OTAIO_WRITE)) { 141 auto cached = filename_cache.find(fd); 142 const char* cached_path = cached->second; 143 if (cached != filename_cache.end() && 144 get_hit_file(cached_path, write_fault_file_name)) { 145 write_fault_file_name = ""; 146 errno = EIO; 147 have_eio_error = true; 148 return -1; 149 } 150 } 151 ssize_t status = write(fd, buf, nbyte); 152 if (status == -1 && errno == EIO) { 153 have_eio_error = true; 154 } 155 return status; 156 } 157 158 int ota_fsync(int fd) { 159 if (should_fault_inject(OTAIO_FSYNC)) { 160 auto cached = filename_cache.find(fd); 161 const char* cached_path = cached->second; 162 if (cached != filename_cache.end() && 163 get_hit_file(cached_path, fsync_fault_file_name)) { 164 fsync_fault_file_name = ""; 165 errno = EIO; 166 have_eio_error = true; 167 return -1; 168 } 169 } 170 int status = fsync(fd); 171 if (status == -1 && errno == EIO) { 172 have_eio_error = true; 173 } 174 return status; 175 } 176 177
