blob: e036e0a4d37d6141c30cf07140f23f31b54443f3 [file] [log] [blame]
Kun Yi64dc05c2018-12-19 13:19:03 -08001#include "binarystore.hpp"
2
Kun Yi97be3af2019-03-05 22:43:41 -08003#include "sys_file.hpp"
4
5#include <sys/types.h>
Kun Yid2d8cb62019-01-10 15:06:12 -08006#include <unistd.h>
7
Kun Yi6baa7132019-01-08 21:21:02 -08008#include <algorithm>
9#include <blobs-ipmid/blobs.hpp>
Kun Yi70059172019-02-22 16:31:42 -080010#include <boost/endian/arithmetic.hpp>
Kun Yid2d8cb62019-01-10 15:06:12 -080011#include <cstdint>
12#include <memory>
Kun Yi8bcf79d2019-01-16 15:17:57 -080013#include <phosphor-logging/elog.hpp>
Kun Yid2d8cb62019-01-10 15:06:12 -080014#include <string>
15#include <vector>
16
17#include "binaryblob.pb.h"
18
19using std::size_t;
20using std::uint16_t;
21using std::uint32_t;
22using std::uint64_t;
23using std::uint8_t;
Kun Yi6baa7132019-01-08 21:21:02 -080024
Kun Yi64dc05c2018-12-19 13:19:03 -080025namespace binstore
26{
27
Kun Yi8bcf79d2019-01-16 15:17:57 -080028using namespace phosphor::logging;
29
Kun Yi64dc05c2018-12-19 13:19:03 -080030std::unique_ptr<BinaryStoreInterface>
31 BinaryStore::createFromConfig(const std::string& baseBlobId,
Kun Yi2765b642019-01-16 11:11:24 -080032 std::unique_ptr<SysFile> file,
33 uint32_t maxSize)
Kun Yi64dc05c2018-12-19 13:19:03 -080034{
Kun Yi2765b642019-01-16 11:11:24 -080035 if (baseBlobId.empty() || !file)
36 {
Kun Yi8bcf79d2019-01-16 15:17:57 -080037 log<level::ERR>("Unable to create binarystore from invalid config",
38 entry("BASE_ID=%s", baseBlobId.c_str()));
Kun Yi2765b642019-01-16 11:11:24 -080039 return nullptr;
40 }
41
42 auto store =
43 std::make_unique<BinaryStore>(baseBlobId, std::move(file), maxSize);
44
Kun Yi8ca234e2019-03-04 10:14:45 -080045 if (!store->loadSerializedData())
46 {
47 return nullptr;
48 }
49
Kun Yi2765b642019-01-16 11:11:24 -080050 return std::move(store);
Kun Yi64dc05c2018-12-19 13:19:03 -080051}
52
Kun Yi97be3af2019-03-05 22:43:41 -080053bool BinaryStore::loadSerializedData()
54{
55 /* Load blob from sysfile if we know it might not match what we have.
56 * Note it will overwrite existing unsaved data per design. */
Kun Yie535a732019-04-03 19:03:25 -070057 if (commitState_ == CommitState::Clean ||
58 commitState_ == CommitState::Uninitialized)
Kun Yi97be3af2019-03-05 22:43:41 -080059 {
60 return true;
61 }
62
63 log<level::NOTICE>("Try loading blob from persistent data",
64 entry("BASE_ID=%s", baseBlobId_.c_str()));
65 try
66 {
67 /* Parse length-prefixed format to protobuf */
68 boost::endian::little_uint64_t size = 0;
69 file_->readToBuf(0, sizeof(size), reinterpret_cast<char*>(&size));
70
71 if (!blob_.ParseFromString(file_->readAsStr(sizeof(uint64_t), size)))
72 {
73 /* Fail to parse the data, which might mean no preexsiting blobs
74 * and is a valid case to handle. Simply init an empty binstore. */
Kun Yie535a732019-04-03 19:03:25 -070075 commitState_ = CommitState::Uninitialized;
Kun Yi97be3af2019-03-05 22:43:41 -080076 }
77 }
Kun Yic83d2fa2019-04-03 18:40:19 -070078 catch (const std::system_error& e)
Kun Yi97be3af2019-03-05 22:43:41 -080079 {
80 /* Read causes unexpected system-level failure */
81 log<level::ERR>("Reading from sysfile failed",
82 entry("ERROR=%s", e.what()));
83 return false;
84 }
Kun Yic83d2fa2019-04-03 18:40:19 -070085 catch (const std::exception& e)
86 {
Kun Yie535a732019-04-03 19:03:25 -070087 /* Non system error originates from junk value in 'size' */
88 commitState_ = CommitState::Uninitialized;
89 }
90
91 if (commitState_ == CommitState::Uninitialized)
92 {
93 log<level::WARNING>("Fail to parse. There might be no persisted blobs",
94 entry("BASE_ID=%s", baseBlobId_.c_str()));
Kun Yic83d2fa2019-04-03 18:40:19 -070095 return true;
96 }
Kun Yi97be3af2019-03-05 22:43:41 -080097
Kun Yi8ca234e2019-03-04 10:14:45 -080098 if (blob_.blob_base_id() != baseBlobId_)
99 {
100 /* Uh oh, stale data loaded. Clean it and commit. */
101 // TODO: it might be safer to add an option in config to error out
102 // instead of to overwrite.
103 log<level::ERR>("Stale blob data, resetting internals...",
104 entry("LOADED=%s", blob_.blob_base_id().c_str()),
105 entry("EXPECTED=%s", baseBlobId_.c_str()));
106 blob_.Clear();
107 blob_.set_blob_base_id(baseBlobId_);
108 return this->commit();
109 }
110
Kun Yi97be3af2019-03-05 22:43:41 -0800111 return true;
112}
113
Kun Yi64dc05c2018-12-19 13:19:03 -0800114std::string BinaryStore::getBaseBlobId() const
115{
116 return baseBlobId_;
117}
118
119std::vector<std::string> BinaryStore::getBlobIds() const
120{
121 std::vector<std::string> result;
122 result.push_back(baseBlobId_);
123
Kun Yi0a940b92019-01-07 16:33:11 -0800124 for (const auto& blob : blob_.blobs())
Kun Yi64dc05c2018-12-19 13:19:03 -0800125 {
Kun Yi0a940b92019-01-07 16:33:11 -0800126 result.push_back(blob.blob_id());
Kun Yi64dc05c2018-12-19 13:19:03 -0800127 }
128
129 return result;
130}
131
132bool BinaryStore::openOrCreateBlob(const std::string& blobId, uint16_t flags)
133{
Kun Yi6baa7132019-01-08 21:21:02 -0800134 if (!(flags & blobs::OpenFlags::read))
135 {
Kun Yi8bcf79d2019-01-16 15:17:57 -0800136 log<level::ERR>("OpenFlags::read not specified when opening",
137 entry("BLOB_ID=%s", blobId.c_str()));
Kun Yi6baa7132019-01-08 21:21:02 -0800138 return false;
139 }
140
141 if (currentBlob_ && (currentBlob_->blob_id() != blobId))
142 {
Kun Yi8bcf79d2019-01-16 15:17:57 -0800143 log<level::ERR>("Already handling a different blob",
144 entry("EXPECTED=%s", currentBlob_->blob_id().c_str()),
145 entry("RECEIVED=%s", blobId.c_str()));
Kun Yi6baa7132019-01-08 21:21:02 -0800146 return false;
147 }
148
149 writable_ = flags & blobs::OpenFlags::write;
150
Kun Yi97be3af2019-03-05 22:43:41 -0800151 /* If there are uncommitted data, discard them. */
152 if (!this->loadSerializedData())
Kun Yid297c9f2019-01-09 13:52:30 -0800153 {
Kun Yi97be3af2019-03-05 22:43:41 -0800154 return false;
Kun Yid297c9f2019-01-09 13:52:30 -0800155 }
156
Kun Yi6baa7132019-01-08 21:21:02 -0800157 /* Iterate and find if there is an existing blob with this id.
158 * blobsPtr points to a BinaryBlob container with STL-like semantics*/
159 auto blobsPtr = blob_.mutable_blobs();
160 auto blobIt =
161 std::find_if(blobsPtr->begin(), blobsPtr->end(),
162 [&](const auto& b) { return b.blob_id() == blobId; });
163
164 if (blobIt != blobsPtr->end())
165 {
166 currentBlob_ = &(*blobIt);
167 return true;
168 }
169
170 /* Otherwise, create the blob and append it */
171 currentBlob_ = blob_.add_blobs();
172 currentBlob_->set_blob_id(blobId);
173
Kun Yi8bcf79d2019-01-16 15:17:57 -0800174 log<level::NOTICE>("Created new blob", entry("BLOB_ID=%s", blobId.c_str()));
Kun Yi6baa7132019-01-08 21:21:02 -0800175 return true;
Kun Yi64dc05c2018-12-19 13:19:03 -0800176}
177
178bool BinaryStore::deleteBlob(const std::string& blobId)
179{
180 return false;
181}
182
183std::vector<uint8_t> BinaryStore::read(uint32_t offset, uint32_t requestedSize)
184{
Kun Yi6967b772019-02-22 13:48:12 -0800185 std::vector<uint8_t> result;
186
187 if (!currentBlob_)
188 {
Kun Yi8bcf79d2019-01-16 15:17:57 -0800189 log<level::ERR>("No open blob to read");
Kun Yi6967b772019-02-22 13:48:12 -0800190 return result;
191 }
192
193 auto dataPtr = currentBlob_->mutable_data();
194
195 /* If it is out of bound, return empty vector */
196 if (offset >= dataPtr->size())
197 {
Kun Yi8bcf79d2019-01-16 15:17:57 -0800198 log<level::ERR>("Read offset is beyond data size",
199 entry("MAX_SIZE=0x%x", dataPtr->size()),
200 entry("RECEIVED_OFFSET=0x%x", offset));
Kun Yi6967b772019-02-22 13:48:12 -0800201 return result;
202 }
203
204 uint32_t requestedEndPos = offset + requestedSize;
205
206 result = std::vector<uint8_t>(
207 dataPtr->begin() + offset,
208 std::min(dataPtr->begin() + requestedEndPos, dataPtr->end()));
Kun Yi64dc05c2018-12-19 13:19:03 -0800209 return result;
210}
211
212bool BinaryStore::write(uint32_t offset, const std::vector<uint8_t>& data)
213{
Kun Yi6967b772019-02-22 13:48:12 -0800214 if (!currentBlob_)
215 {
Kun Yi8bcf79d2019-01-16 15:17:57 -0800216 log<level::ERR>("No open blob to write");
Kun Yi6967b772019-02-22 13:48:12 -0800217 return false;
218 }
219
220 if (!writable_)
221 {
Kun Yi8bcf79d2019-01-16 15:17:57 -0800222 log<level::ERR>("Open blob is not writable");
Kun Yi6967b772019-02-22 13:48:12 -0800223 return false;
224 }
225
226 auto dataPtr = currentBlob_->mutable_data();
227
228 if (offset > dataPtr->size())
229 {
Kun Yi8bcf79d2019-01-16 15:17:57 -0800230 log<level::ERR>("Write would leave a gap with undefined data. Return.");
Kun Yi6967b772019-02-22 13:48:12 -0800231 return false;
232 }
233
234 /* Copy (overwrite) the data */
235 if (offset + data.size() > dataPtr->size())
236 {
237 dataPtr->resize(offset + data.size()); // not enough space, extend
238 }
239 std::copy(data.begin(), data.end(), dataPtr->begin() + offset);
240 return true;
Kun Yi64dc05c2018-12-19 13:19:03 -0800241}
242
243bool BinaryStore::commit()
244{
Kun Yi70059172019-02-22 16:31:42 -0800245 /* Store as little endian to be platform agnostic. Consistent with read. */
Kun Yid297c9f2019-01-09 13:52:30 -0800246 auto blobData = blob_.SerializeAsString();
Kun Yi70059172019-02-22 16:31:42 -0800247 boost::endian::little_uint64_t sizeLE = blobData.size();
248 std::string commitData(sizeLE.data(), sizeof(sizeLE));
Kun Yid297c9f2019-01-09 13:52:30 -0800249 commitData += blobData;
250
251 try
252 {
253 file_->writeStr(commitData, 0);
254 }
255 catch (const std::exception& e)
256 {
Kun Yid297c9f2019-01-09 13:52:30 -0800257 commitState_ = CommitState::CommitError;
Kun Yi8bcf79d2019-01-16 15:17:57 -0800258 log<level::ERR>("Writing to sysfile failed",
259 entry("ERROR=%s", e.what()));
Kun Yid297c9f2019-01-09 13:52:30 -0800260 return false;
261 };
262
263 commitState_ = CommitState::Clean;
264 return true;
Kun Yi64dc05c2018-12-19 13:19:03 -0800265}
266
267bool BinaryStore::close()
268{
Kun Yi6baa7132019-01-08 21:21:02 -0800269 currentBlob_ = nullptr;
270 writable_ = false;
Kun Yid297c9f2019-01-09 13:52:30 -0800271 commitState_ = CommitState::Dirty;
Kun Yi6baa7132019-01-08 21:21:02 -0800272 return true;
Kun Yi64dc05c2018-12-19 13:19:03 -0800273}
274
275bool BinaryStore::stat()
276{
277 return false;
278}
279
280} // namespace binstore