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
get_hit_file(const char * cached_path,std::string ffn)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
ota_set_fault_files()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
ota_open(const char * path,int oflags)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
ota_open(const char * path,int oflags,mode_t mode)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
ota_fopen(const char * path,const char * mode)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
ota_close(int fd)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
ota_fclose(FILE * fh)77 int ota_fclose(FILE* fh) {
78 filename_cache.erase((intptr_t)fh);
79 return fclose(fh);
80 }
81
ota_fread(void * ptr,size_t size,size_t nitems,FILE * stream)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
ota_read(int fd,void * buf,size_t nbyte)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
ota_fwrite(const void * ptr,size_t size,size_t count,FILE * stream)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
ota_write(int fd,const void * buf,size_t nbyte)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
ota_fsync(int fd)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