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 "ota_io.h" 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 <map> 26 #include <memory> 27 28 #include "config.h" 29 30 static std::map<intptr_t, const char*> filename_cache; 31 static std::string read_fault_file_name = ""; 32 static std::string write_fault_file_name = ""; 33 static std::string fsync_fault_file_name = ""; 34 35 static bool get_hit_file(const char* cached_path, const std::string& ffn) { 36 return should_hit_cache() 37 ? !strncmp(cached_path, OTAIO_CACHE_FNAME, strlen(cached_path)) 38 : !strncmp(cached_path, ffn.c_str(), strlen(cached_path)); 39 } 40 41 void ota_set_fault_files() { 42 if (should_fault_inject(OTAIO_READ)) { 43 read_fault_file_name = fault_fname(OTAIO_READ); 44 } 45 if (should_fault_inject(OTAIO_WRITE)) { 46 write_fault_file_name = fault_fname(OTAIO_WRITE); 47 } 48 if (should_fault_inject(OTAIO_FSYNC)) { 49 fsync_fault_file_name = fault_fname(OTAIO_FSYNC); 50 } 51 } 52 53 bool have_eio_error = false; 54 55 int ota_open(const char* path, int oflags) { 56 // Let the caller handle errors; we do not care if open succeeds or fails 57 int fd = open(path, oflags); 58 filename_cache[fd] = path; 59 return fd; 60 } 61 62 int ota_open(const char* path, int oflags, mode_t mode) { 63 int fd = open(path, oflags, mode); 64 filename_cache[fd] = path; 65 return fd; } 66 67 FILE* ota_fopen(const char* path, const char* mode) { 68 FILE* fh = fopen(path, mode); 69 filename_cache[(intptr_t)fh] = path; 70 return fh; 71 } 72 73 static int __ota_close(int fd) { 74 // descriptors can be reused, so make sure not to leave them in the cache 75 filename_cache.erase(fd); 76 return close(fd); 77 } 78 79 void OtaCloser::Close(int fd) { 80 __ota_close(fd); 81 } 82 83 int ota_close(unique_fd& fd) { 84 return __ota_close(fd.release()); 85 } 86 87 static int __ota_fclose(FILE* fh) { 88 filename_cache.erase(reinterpret_cast<intptr_t>(fh)); 89 return fclose(fh); 90 } 91 92 void OtaFcloser::operator()(FILE* f) const { 93 __ota_fclose(f); 94 }; 95 96 int ota_fclose(unique_file& fh) { 97 return __ota_fclose(fh.release()); 98 } 99 100 size_t ota_fread(void* ptr, size_t size, size_t nitems, FILE* stream) { 101 if (should_fault_inject(OTAIO_READ)) { 102 auto cached = filename_cache.find((intptr_t)stream); 103 const char* cached_path = cached->second; 104 if (cached != filename_cache.end() && 105 get_hit_file(cached_path, read_fault_file_name)) { 106 read_fault_file_name = ""; 107 errno = EIO; 108 have_eio_error = true; 109 return 0; 110 } 111 } 112 size_t status = fread(ptr, size, nitems, stream); 113 // If I/O error occurs, set the retry-update flag. 114 if (status != nitems && errno == EIO) { 115 have_eio_error = true; 116 } 117 return status; 118 } 119 120 ssize_t ota_read(int fd, void* buf, size_t nbyte) { 121 if (should_fault_inject(OTAIO_READ)) { 122 auto cached = filename_cache.find(fd); 123 const char* cached_path = cached->second; 124 if (cached != filename_cache.end() 125 && get_hit_file(cached_path, read_fault_file_name)) { 126 read_fault_file_name = ""; 127 errno = EIO; 128 have_eio_error = true; 129 return -1; 130 } 131 } 132 ssize_t status = read(fd, buf, nbyte); 133 if (status == -1 && errno == EIO) { 134 have_eio_error = true; 135 } 136 return status; 137 } 138 139 size_t ota_fwrite(const void* ptr, size_t size, size_t count, FILE* stream) { 140 if (should_fault_inject(OTAIO_WRITE)) { 141 auto cached = filename_cache.find((intptr_t)stream); 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 0; 149 } 150 } 151 size_t status = fwrite(ptr, size, count, stream); 152 if (status != count && errno == EIO) { 153 have_eio_error = true; 154 } 155 return status; 156 } 157 158 ssize_t ota_write(int fd, const void* buf, size_t nbyte) { 159 if (should_fault_inject(OTAIO_WRITE)) { 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, write_fault_file_name)) { 164 write_fault_file_name = ""; 165 errno = EIO; 166 have_eio_error = true; 167 return -1; 168 } 169 } 170 ssize_t status = write(fd, buf, nbyte); 171 if (status == -1 && errno == EIO) { 172 have_eio_error = true; 173 } 174 return status; 175 } 176 177 int ota_fsync(int fd) { 178 if (should_fault_inject(OTAIO_FSYNC)) { 179 auto cached = filename_cache.find(fd); 180 const char* cached_path = cached->second; 181 if (cached != filename_cache.end() && 182 get_hit_file(cached_path, fsync_fault_file_name)) { 183 fsync_fault_file_name = ""; 184 errno = EIO; 185 have_eio_error = true; 186 return -1; 187 } 188 } 189 int status = fsync(fd); 190 if (status == -1 && errno == EIO) { 191 have_eio_error = true; 192 } 193 return status; 194 } 195 196
