GCC Code Coverage Report

Directory: ./
File: Os/File.cpp
Date: 2026-09-03 22:12:29
Exec Total Coverage
Lines: 100 211 47.4%
Functions: 15 27 55.6%
Branches: 29 89 32.6%
Line Branch Exec Source
1 // ======================================================================
2 // \title Os/File.cpp
3 // \brief common function implementation for Os::File
4 // ======================================================================
5 #include <Fw/Types/Assert.hpp>
6 #include <Fw/Types/StringUtils.hpp>
7 #include <Os/File.hpp>
8 #include <algorithm>
9 #include <config/FppConstantsAc.hpp>
10
11 namespace Os {
12
13
6/6
✓ Branch 2 taken 946 times.
✓ Branch 4 taken 484352 times.
✓ Branch 5 taken 946 times.
✓ Branch 6 taken 15136 times.
✓ Branch 7 taken 946 times.
✓ Branch 9 taken 946 times.
 500434 File::File() : m_crc_buffer(), m_handle_storage(), m_delegate(*FileInterface::getDelegate(m_handle_storage)) {
14 946 FW_ASSERT(&this->m_delegate == reinterpret_cast<FileInterface*>(&this->m_handle_storage[0]));
15 946 }
16
17 1892 File::~File() {
18 1892 FW_ASSERT(&this->m_delegate == reinterpret_cast<FileInterface*>(&this->m_handle_storage[0]));
19
2/2
✓ Branch 0 taken 942 times.
✓ Branch 1 taken 4 times.
 1892 if (this->m_mode != OPEN_NO_MODE) {
20 1884 this->close();
21 }
22 1892 m_delegate.~FileInterface();
23 1892 }
24
25 ✗ File::File(const File& other)
26 ✗ : m_mode(other.m_mode),
27 ✗ m_hash(other.m_hash),
28 ✗ m_crc_buffer(),
29 ✗ m_handle_storage(),
30 ✗ m_delegate(*FileInterface::getDelegate(m_handle_storage, &other.m_delegate)) {
31 ✗ FW_ASSERT(&this->m_delegate == reinterpret_cast<FileInterface*>(&this->m_handle_storage[0]));
32 ✗ }
33
34 ✗ File& File::operator=(const File& other) {
35 ✗ if (this != &other) {
36 // The delegate below is constructed over the storage of the existing one. Any file this
37 // object currently holds must be closed first or its handle is orphaned permanently.
38 ✗ if (this->m_mode != OPEN_NO_MODE) {
39 ✗ this->close();
40 }
41 ✗ this->m_delegate.~FileInterface();
42 ✗ this->m_mode = other.m_mode;
43 ✗ this->m_hash = other.m_hash;
44 ✗ (void)FileInterface::getDelegate(m_handle_storage, &other.m_delegate);
45 ✗ FW_ASSERT(&this->m_delegate == reinterpret_cast<FileInterface*>(&this->m_handle_storage[0]));
46 }
47 ✗ return *this;
48 }
49
50 944 File::Status File::open(const CHAR* filepath, File::Mode requested_mode) {
51 944 return this->open(filepath, requested_mode, OverwriteType::NO_OVERWRITE);
52 }
53
54 945 File::Status File::open(const CHAR* filepath, File::Mode requested_mode, File::OverwriteType overwrite) {
55 945 FW_ASSERT(nullptr != filepath);
56 945 return this->open(filepath, static_cast<FwSizeType>(FileNameStringSize + 1), requested_mode, overwrite);
57 }
58
59 ✗ File::Status File::open(const CHAR* filepath, FwSizeType length, File::Mode requested_mode) {
60 ✗ return this->open(filepath, length, requested_mode, OverwriteType::NO_OVERWRITE);
61 }
62
63 945 File::Status File::open(const CHAR* filepath,
64 FwSizeType length,
65 File::Mode requested_mode,
66 File::OverwriteType overwrite) {
67 945 FW_ASSERT(&this->m_delegate == reinterpret_cast<FileInterface*>(&this->m_handle_storage[0]));
68 945 FW_ASSERT(nullptr != filepath);
69 945 const FwSizeType string_len = static_cast<FwSizeType>(Fw::StringUtils::string_length(filepath, length));
70 945 FW_ASSERT(string_len < length, static_cast<FwAssertArgType>(string_len), static_cast<FwAssertArgType>(length));
71 945 FW_ASSERT(File::Mode::OPEN_NO_MODE < requested_mode && File::Mode::MAX_OPEN_MODE > requested_mode);
72 945 FW_ASSERT((0 <= this->m_mode) && (this->m_mode < Mode::MAX_OPEN_MODE));
73 945 FW_ASSERT((0 <= overwrite) && (overwrite < OverwriteType::MAX_OVERWRITE_TYPE));
74 // Check for already opened file
75
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 945 times.
 945 if (this->isOpen()) {
76 ✗ return File::Status::INVALID_MODE;
77 }
78 945 File::Status status = this->m_delegate.open(filepath, requested_mode, overwrite);
79
1/2
✓ Branch 0 taken 945 times.
✗ Branch 1 not taken.
 945 if (status == File::Status::OP_OK) {
80 945 this->m_mode = requested_mode;
81 // Reset any open CRC calculations
82 945 this->m_hash.init();
83 }
84
85 945 return status;
86 }
87
88 ✗ File::Status File::open(const Fw::ConstStringBase& path, File::Mode requested_mode) {
89 ✗ return this->open(path.toChar(), static_cast<FwSizeType>(path.getCapacity()), requested_mode,
90 ✗ OverwriteType::NO_OVERWRITE);
91 }
92
93 ✗ File::Status File::open(const Fw::ConstStringBase& path, File::Mode requested_mode, File::OverwriteType overwrite) {
94 ✗ return this->open(path.toChar(), static_cast<FwSizeType>(path.getCapacity()), requested_mode, overwrite);
95 }
96
97 947 void File::close() {
98 947 FW_ASSERT(&this->m_delegate == reinterpret_cast<FileInterface*>(&this->m_handle_storage[0]));
99 947 FW_ASSERT(this->m_mode < Mode::MAX_OPEN_MODE);
100 947 FW_ASSERT((0 <= this->m_mode) && (this->m_mode < Mode::MAX_OPEN_MODE));
101 947 this->m_delegate.close();
102 947 this->m_mode = Mode::OPEN_NO_MODE;
103 947 }
104
105 948 bool File::isOpen() const {
106 948 FW_ASSERT(&this->m_delegate == reinterpret_cast<const FileInterface*>(&this->m_handle_storage[0]));
107 948 FW_ASSERT((0 <= this->m_mode) && (this->m_mode < Mode::MAX_OPEN_MODE));
108 948 return this->m_mode != Mode::OPEN_NO_MODE;
109 }
110
111 ✗ File::Status File::size(FwSizeType& size_result) {
112 ✗ FW_ASSERT(&this->m_delegate == reinterpret_cast<FileInterface*>(&this->m_handle_storage[0]));
113 ✗ FW_ASSERT((0 <= this->m_mode) && (this->m_mode < Mode::MAX_OPEN_MODE));
114 ✗ if (OPEN_NO_MODE == this->m_mode) {
115 ✗ return File::Status::NOT_OPENED;
116 }
117 ✗ return this->m_delegate.size(size_result);
118 }
119
120 3290 File::Status File::position(FwSizeType& position_result) {
121 3290 FW_ASSERT(&this->m_delegate == reinterpret_cast<FileInterface*>(&this->m_handle_storage[0]));
122 3290 FW_ASSERT((0 <= this->m_mode) && (this->m_mode < Mode::MAX_OPEN_MODE));
123 // Check that the file is open before attempting operation
124
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3290 times.
 3290 if (OPEN_NO_MODE == this->m_mode) {
125 ✗ return File::Status::NOT_OPENED;
126 }
127 3290 return this->m_delegate.position(position_result);
128 }
129
130 ✗ File::Status File::preallocate(FwSizeType offset, FwSizeType length) {
131 ✗ FW_ASSERT(&this->m_delegate == reinterpret_cast<FileInterface*>(&this->m_handle_storage[0]));
132 ✗ FW_ASSERT((0 <= this->m_mode) && (this->m_mode < Mode::MAX_OPEN_MODE));
133 // Check that the file is open before attempting operation
134 ✗ if (OPEN_NO_MODE == this->m_mode) {
135 ✗ return File::Status::NOT_OPENED;
136 ✗ } else if (OPEN_READ == this->m_mode) {
137 ✗ return File::Status::INVALID_MODE;
138 }
139 ✗ return this->m_delegate.preallocate(offset, length);
140 }
141
142 3291 File::Status File::seek(FwSignedSizeType offset, File::SeekType seekType) {
143 3291 FW_ASSERT(&this->m_delegate == reinterpret_cast<FileInterface*>(&this->m_handle_storage[0]));
144 3291 FW_ASSERT((0 <= seekType) && (seekType < SeekType::MAX_SEEK_TYPE));
145 // Cannot do a seek with a negative offset in absolute mode
146 3291 FW_ASSERT((seekType == File::SeekType::RELATIVE) || (offset >= 0));
147 3291 FW_ASSERT((0 <= this->m_mode) && (this->m_mode < Mode::MAX_OPEN_MODE));
148 // Check that the file is open before attempting operation
149
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3291 times.
 3291 if (OPEN_NO_MODE == this->m_mode) {
150 ✗ return File::Status::NOT_OPENED;
151 }
152 3291 return this->m_delegate.seek(offset, seekType);
153 }
154
155 3290 File::Status File::seek_absolute(FwSizeType offset) {
156 3290 Os::File::Status status = File::Status::OTHER_ERROR;
157 // If the offset can be represented by a signed value, then we can perform a single seek
158
1/2
✓ Branch 1 taken 3290 times.
✗ Branch 2 not taken.
 3290 if (static_cast<FwSizeType>(std::numeric_limits<FwSignedSizeType>::max()) >= offset) {
159 // Check that the bounding above is correct
160 3290 FW_ASSERT(static_cast<FwSignedSizeType>(offset) >= 0);
161 3290 status = this->seek(static_cast<FwSignedSizeType>(offset), File::SeekType::ABSOLUTE);
162 }
163 // Otherwise, a full seek to any value represented by FwSizeType can be performed
164 // by at most 3 seeks of a FwSignedSizeType. Two half seeks (rounded down) that are
165 // strictly bounded by std::numeric_limits<FwSignedSizeType>::max() and one seek of
166 // a possibile "odd" byte to ensure odds offsets do not introduce an off-by-one-error.
167 // Thus we perform 3 seeks to guarantee that we can reach any position.
168 else {
169 ✗ FwSignedSizeType half_offset = static_cast<FwSignedSizeType>(offset >> 1);
170 ✗ bool is_odd = (offset % 2) == 1;
171 ✗ status = this->seek(half_offset, File::SeekType::ABSOLUTE);
172 ✗ if (status == File::Status::OP_OK) {
173 ✗ status = this->seek(half_offset, File::SeekType::RELATIVE);
174 }
175 ✗ if (status == File::Status::OP_OK) {
176 ✗ status = this->seek((is_odd) ? 1 : 0, File::SeekType::RELATIVE);
177 }
178 }
179 3290 return status;
180 }
181
182 ✗ File::Status File::flush() {
183 ✗ FW_ASSERT(&this->m_delegate == reinterpret_cast<FileInterface*>(&this->m_handle_storage[0]));
184 ✗ FW_ASSERT(this->m_mode < Mode::MAX_OPEN_MODE);
185 // Check that the file is open before attempting operation
186 ✗ if (OPEN_NO_MODE == this->m_mode) {
187 ✗ return File::Status::NOT_OPENED;
188 ✗ } else if (OPEN_READ == this->m_mode) {
189 ✗ return File::Status::INVALID_MODE;
190 }
191 ✗ return this->m_delegate.flush();
192 }
193
194 4 File::Status File::read(U8* buffer, FwSizeType& size) {
195 4 return this->read(buffer, size, WaitType::WAIT);
196 }
197
198 3294 File::Status File::read(U8* buffer, FwSizeType& size, File::WaitType wait) {
199 3294 FW_ASSERT(&this->m_delegate == reinterpret_cast<FileInterface*>(&this->m_handle_storage[0]));
200 3294 FW_ASSERT(buffer != nullptr);
201 3294 FW_ASSERT(this->m_mode < Mode::MAX_OPEN_MODE);
202 // Check that the file is open before attempting operation
203
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3294 times.
 3294 if (OPEN_NO_MODE == this->m_mode) {
204 ✗ size = 0;
205 ✗ return File::Status::NOT_OPENED;
206
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3294 times.
 3294 } else if (OPEN_READ != this->m_mode) {
207 ✗ size = 0;
208 ✗ return File::Status::INVALID_MODE;
209 }
210 3294 return this->m_delegate.read(buffer, size, wait);
211 }
212
213 2 File::Status File::write(const U8* buffer, FwSizeType& size) {
214 2 return this->write(buffer, size, WaitType::WAIT);
215 }
216
217 3 File::Status File::write(const U8* buffer, FwSizeType& size, File::WaitType wait) {
218 3 FW_ASSERT(&this->m_delegate == reinterpret_cast<FileInterface*>(&this->m_handle_storage[0]));
219 3 FW_ASSERT(buffer != nullptr);
220 3 FW_ASSERT(this->m_mode < Mode::MAX_OPEN_MODE);
221 // Check that the file is open before attempting operation
222
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
 3 if (OPEN_NO_MODE == this->m_mode) {
223 ✗ size = 0;
224 ✗ return File::Status::NOT_OPENED;
225
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
 3 } else if (OPEN_READ == this->m_mode) {
226 ✗ size = 0;
227 ✗ return File::Status::INVALID_MODE;
228 }
229 3 return this->m_delegate.write(buffer, size, wait);
230 }
231
232 ✗ FileHandle* File::getHandle() {
233 ✗ FW_ASSERT(&this->m_delegate == reinterpret_cast<FileInterface*>(&this->m_handle_storage[0]));
234 ✗ return this->m_delegate.getHandle();
235 }
236
237 ✗ File::Status File::calculateCrc(U32& crc) {
238 ✗ File::Status status = File::Status::OP_OK;
239 ✗ FwSizeType size = FW_FILE_CHUNK_SIZE;
240 ✗ crc = 0;
241 ✗ for (FwSizeType i = 0; i < std::numeric_limits<FwSizeType>::max(); i++) {
242 ✗ status = this->incrementalCrc(size);
243 // Break on eof or error
244 ✗ if ((size != FW_FILE_CHUNK_SIZE) || (status != File::OP_OK)) {
245 break;
246 }
247 }
248 // When successful, finalize the CRC
249 ✗ if (status == File::OP_OK) {
250 ✗ status = this->finalizeCrc(crc);
251 }
252 ✗ return status;
253 }
254
255 ✗ File::Status File::incrementalCrc(FwSizeType& size) {
256 ✗ File::Status status = File::Status::OP_OK;
257 ✗ FW_ASSERT(size <= FW_FILE_CHUNK_SIZE, FwAssertArgType(size));
258 ✗ if (OPEN_NO_MODE == this->m_mode) {
259 ✗ status = File::Status::NOT_OPENED;
260 ✗ } else if (OPEN_READ != this->m_mode) {
261 ✗ status = File::Status::INVALID_MODE;
262 } else {
263 // Read data without waiting for additional data to be available
264 ✗ status = this->read(this->m_crc_buffer, size, File::WaitType::NO_WAIT);
265 ✗ if (OP_OK == status) {
266 ✗ FW_ASSERT(size <= FW_FILE_CHUNK_SIZE, FwAssertArgType(size));
267 ✗ this->m_hash.update(this->m_crc_buffer, size);
268 }
269 }
270 ✗ return status;
271 }
272
273 ✗ File::Status File::finalizeCrc(U32& crc) {
274 ✗ File::Status status = File::Status::OP_OK;
275 ✗ this->m_hash.finalize(crc);
276 // Historically, the CRC calculation in File omitted the final 1's complement step. Utils::Hash performs that step
277 // and as such, we must undo it before returning the value to ensure backwards compatibility.
278 ✗ crc = ~crc;
279 ✗ this->m_hash.init();
280 ✗ return status;
281 }
282
283 3290 File::Status File::readline(U8* buffer, FwSizeType& size, File::WaitType wait) {
284 3290 const FwSizeType requested_size = size;
285 3290 FW_ASSERT(&this->m_delegate == reinterpret_cast<FileInterface*>(&this->m_handle_storage[0]));
286 3290 FW_ASSERT(buffer != nullptr);
287 3290 FW_ASSERT(this->m_mode < Mode::MAX_OPEN_MODE);
288 // Check that the file is open before attempting operation
289
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3290 times.
 3290 if (OPEN_NO_MODE == this->m_mode) {
290 ✗ size = 0;
291 ✗ return File::Status::NOT_OPENED;
292
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3290 times.
 3290 } else if (OPEN_READ != this->m_mode) {
293 ✗ size = 0;
294 ✗ return File::Status::INVALID_MODE;
295 }
296 3290 FwSizeType original_location = 0;
297
1/1
✓ Branch 1 taken 3290 times.
 3290 File::Status status = this->position(original_location);
298
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3290 times.
 3290 if (status != Os::File::Status::OP_OK) {
299 ✗ size = 0;
300 ✗ (void)this->seek_absolute(original_location);
301 ✗ return status;
302 }
303 3290 FwSizeType read = 0;
304 // Loop reading chunk by chunk
305
1/2
✓ Branch 0 taken 3290 times.
✗ Branch 1 not taken.
 3290 for (FwSizeType i = 0; i < size; i += read) {
306 // read in chunks to avoid large buffer allocations
307 3290 FwSizeType current_chunk_size = std::min(size - i, static_cast<FwSizeType>(FW_FILE_CHUNK_SIZE));
308 3290 read = current_chunk_size;
309
1/1
✓ Branch 1 taken 3290 times.
 3290 status = this->read(buffer + i, read, wait);
310
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3290 times.
 3290 if (status != File::Status::OP_OK) {
311 // Contract: on error, seek back to the original location
312 ✗ size = 0;
313 ✗ (void)this->seek_absolute(original_location);
314 ✗ return status;
315 }
316 // EOF break out now
317
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3290 times.
 3290 if (read == 0) {
318 ✗ size = i;
319 ✗ return Os::File::Status::OP_OK;
320 }
321 // Loop from i to i + current_chunk_size looking for `\n`
322 3290 const FwSizeType chunk_end = i + read;
323
1/2
✓ Branch 0 taken 130331 times.
✗ Branch 1 not taken.
 130331 for (FwSizeType j = i; j < chunk_end; j++) {
324 // Newline seek back to after it, return the size read
325
2/2
✓ Branch 0 taken 3290 times.
✓ Branch 1 taken 127041 times.
 130331 if (buffer[j] == '\n') {
326 3290 size = j + 1;
327 // Ensure that the computation worked and there is not overflow
328 3290 FW_ASSERT(size <= requested_size);
329 3290 FW_ASSERT(std::numeric_limits<FwSizeType>::max() - size >= original_location);
330
1/1
✓ Branch 1 taken 3290 times.
 3290 (void)this->seek_absolute(original_location + j + 1);
331 3290 return Os::File::Status::OP_OK;
332 }
333 }
334 }
335 // Failed to find newline within data available
336 // Contract: on error, seek back to the original location
337 ✗ size = 0;
338 ✗ (void)this->seek_absolute(original_location);
339 ✗ return Os::File::Status::OTHER_ERROR;
340 }
341 } // namespace Os
342