blob: b42907c85a1590b63b473f72db0fedfb25e62866 [file] [log] [blame]
Deepak Kodihalli393821d2017-04-28 04:44:38 -05001#include "pnor_partition_table.hpp"
2#include "common.h"
3#include "config.h"
Deepak Kodihalli8a899692017-07-11 23:17:19 -05004#include "xyz/openbmc_project/Common/error.hpp"
5#include <phosphor-logging/elog-errors.hpp>
Deepak Kodihalli393821d2017-04-28 04:44:38 -05006#include <syslog.h>
7#include <endian.h>
8#include <regex>
9#include <fstream>
10#include <algorithm>
11
12namespace openpower
13{
14namespace virtual_pnor
15{
16
Deepak Kodihalli8a899692017-07-11 23:17:19 -050017using namespace phosphor::logging;
18using namespace sdbusplus::xyz::openbmc_project::Common::Error;
19
Deepak Kodihalli393821d2017-04-28 04:44:38 -050020namespace partition
21{
Deepak Kodihalli393821d2017-04-28 04:44:38 -050022
Deepak Kodihallid1d79302017-07-11 23:01:39 -050023Table::Table(size_t blockSize, size_t pnorSize):
24 Table(fs::path(PARTITION_FILES_RO_LOC), blockSize, pnorSize)
Deepak Kodihalli393821d2017-04-28 04:44:38 -050025{
26}
27
Deepak Kodihallid1d79302017-07-11 23:01:39 -050028Table::Table(fs::path&& directory,
29 size_t blockSize, size_t pnorSize):
Deepak Kodihalli393821d2017-04-28 04:44:38 -050030 szBlocks(0),
Deepak Kodihalli393821d2017-04-28 04:44:38 -050031 directory(std::move(directory)),
Deepak Kodihallid1d79302017-07-11 23:01:39 -050032 numParts(0),
33 blockSize(blockSize),
34 pnorSize(pnorSize)
Deepak Kodihalli393821d2017-04-28 04:44:38 -050035{
36 preparePartitions();
37 prepareHeader();
38 hostTbl = endianFixup(tbl);
39}
40
41void Table::prepareHeader()
42{
43 decltype(auto) table = getNativeTable();
44 table.data.magic = PARTITION_HEADER_MAGIC;
45 table.data.version = PARTITION_VERSION_1;
46 table.data.size = szBlocks;
47 table.data.entry_size = sizeof(pnor_partition);
48 table.data.entry_count = numParts;
Deepak Kodihallid1d79302017-07-11 23:01:39 -050049 table.data.block_size = blockSize;
50 table.data.block_count = pnorSize / blockSize;
Deepak Kodihalli393821d2017-04-28 04:44:38 -050051 table.checksum = details::checksum(table.data);
52}
53
54inline void Table::allocateMemory(const fs::path& tocFile)
55{
56 size_t num = 0;
57 std::string line;
58 std::ifstream file(tocFile.c_str());
59
60 // Find number of lines in partition file - this will help
61 // determine the number of partitions and hence also how much
62 // memory to allocate for the partitions array.
63 // The actual number of partitions may turn out to be lesser than this,
64 // in case of errors.
65 while (std::getline(file, line))
66 {
67 // Check if line starts with "partition"
68 if (std::string::npos != line.find("partition", 0))
69 {
70 ++num;
71 }
72 }
73
74 size_t totalSizeBytes = sizeof(pnor_partition_table) +
75 (num * sizeof(pnor_partition));
Deepak Kodihallid1d79302017-07-11 23:01:39 -050076 size_t totalSizeAligned = align_up(totalSizeBytes, blockSize);
77 szBlocks = totalSizeAligned / blockSize;
Deepak Kodihalli393821d2017-04-28 04:44:38 -050078 tbl.resize(totalSizeAligned);
79}
80
81inline void Table::writeSizes(pnor_partition& part, size_t start, size_t end)
82{
83 size_t size = end - start;
Adriana Kobylak2ad21322017-11-28 14:59:19 -060084 part.data.base = align_up(start, blockSize) / blockSize;
Deepak Kodihallid1d79302017-07-11 23:01:39 -050085 size_t sizeInBlocks = align_up(size, blockSize) / blockSize;
Deepak Kodihalli393821d2017-04-28 04:44:38 -050086 part.data.size = sizeInBlocks;
Adriana Kobylakeb083552017-08-04 14:03:32 -050087
88 // If a a patch partition file exists, populate actual size with its file
89 // size if it is smaller than the total size.
90 fs::path patchFile(PARTITION_FILES_PATCH_LOC);
91 patchFile /= part.data.name;
92 if (fs::is_regular_file(patchFile))
93 {
94 part.data.actual = std::min(
95 size, static_cast<size_t>(fs::file_size(patchFile)));
96 }
97 else
98 {
99 part.data.actual = size;
100 }
Deepak Kodihalli393821d2017-04-28 04:44:38 -0500101}
102
Deepak Kodihallie8b0e8a2017-07-12 10:01:31 -0500103inline void Table::writeUserdata(pnor_partition& part,
104 uint32_t version,
105 const std::string& data)
Deepak Kodihalli393821d2017-04-28 04:44:38 -0500106{
Adriana Kobylakacb32ef2017-12-05 16:12:06 -0600107 std::istringstream stream(data);
108 std::string flag {};
109 auto perms = 0;
110
111 while (std::getline(stream, flag, ','))
Deepak Kodihalli393821d2017-04-28 04:44:38 -0500112 {
Adriana Kobylakacb32ef2017-12-05 16:12:06 -0600113 if (flag == "ECC")
114 {
115 part.data.user.data[0] = PARTITION_ECC_PROTECTED;
116 }
117 else if (flag == "READONLY")
118 {
119 perms |= PARTITION_READONLY;
120 }
121 else if (flag == "PRESERVED")
122 {
123 perms |= PARTITION_PRESERVED;
124 }
125 else if (flag == "REPROVISION")
126 {
127 perms |= PARTITION_REPROVISION;
128 }
129 else if (flag == "VOLATILE")
130 {
131 perms |= PARTITION_VOLATILE;
132 }
133 else if (flag == "CLEARECC")
134 {
135 perms |= PARTITION_CLEARECC;
136 }
Deepak Kodihalli393821d2017-04-28 04:44:38 -0500137 }
Deepak Kodihallie8b0e8a2017-07-12 10:01:31 -0500138
Deepak Kodihalli393821d2017-04-28 04:44:38 -0500139 part.data.user.data[1] = perms;
Deepak Kodihallie8b0e8a2017-07-12 10:01:31 -0500140
141 part.data.user.data[1] |= version;
Deepak Kodihalli393821d2017-04-28 04:44:38 -0500142}
143
144inline void Table::writeDefaults(pnor_partition& part)
145{
146 part.data.pid = PARENT_PATITION_ID;
147 part.data.type = PARTITION_TYPE_DATA;
148 part.data.flags = 0; // flags unused
149}
150
151inline void Table::writeNameAndId(pnor_partition& part, std::string&& name,
152 const std::string& id)
153{
154 name.resize(PARTITION_NAME_MAX);
155 memcpy(part.data.name,
156 name.c_str(),
157 sizeof(part.data.name));
158 part.data.id = std::stoul(id);
159}
160
161void Table::preparePartitions()
162{
163 fs::path tocFile = directory;
164 tocFile /= PARTITION_TOC_FILE;
165 allocateMemory(tocFile);
166
167 std::ifstream file(tocFile.c_str());
168 static constexpr auto ID_MATCH = 1;
169 static constexpr auto NAME_MATCH = 2;
Adriana Kobylak1e1bdc72017-08-16 16:30:08 -0500170 static constexpr auto START_ADDR_MATCH = 4;
171 static constexpr auto END_ADDR_MATCH = 6;
172 static constexpr auto VERSION_MATCH = 8;
Deepak Kodihalli393821d2017-04-28 04:44:38 -0500173 // Parse PNOR toc (table of contents) file, which has lines like :
Adriana Kobylak1e1bdc72017-08-16 16:30:08 -0500174 // partition01=HBB,0x00010000,0x000a0000,0x80,ECC,PRESERVED, to indicate
Deepak Kodihallie8b0e8a2017-07-12 10:01:31 -0500175 // partition information
Deepak Kodihalli393821d2017-04-28 04:44:38 -0500176 std::regex regex
177 {
178 "^partition([0-9]+)=([A-Za-z0-9_]+),"
Adriana Kobylak1e1bdc72017-08-16 16:30:08 -0500179 "(0x)?([0-9a-fA-F]+),(0x)?([0-9a-fA-F]+),(0x)?([A-Fa-f0-9]{2})",
Deepak Kodihalli393821d2017-04-28 04:44:38 -0500180 std::regex::extended
181 };
182 std::smatch match;
183 std::string line;
Deepak Kodihallie8b0e8a2017-07-12 10:01:31 -0500184 constexpr auto versionShift = 24;
Deepak Kodihalli393821d2017-04-28 04:44:38 -0500185
186 decltype(auto) table = getNativeTable();
187
188 while (std::getline(file, line))
189 {
190 if (std::regex_search(line, match, regex))
191 {
192 fs::path partitionFile = directory;
193 partitionFile /= match[NAME_MATCH].str();
194 if (!fs::exists(partitionFile))
195 {
196 MSG_ERR("Partition file %s does not exist",
197 partitionFile.c_str());
198 continue;
199 }
200
201 writeNameAndId(table.partitions[numParts],
202 match[NAME_MATCH].str(),
203 match[ID_MATCH].str());
204 writeDefaults(table.partitions[numParts]);
205 writeSizes(table.partitions[numParts],
206 std::stoul(match[START_ADDR_MATCH].str(), nullptr, 16),
207 std::stoul(match[END_ADDR_MATCH].str(), nullptr, 16));
Deepak Kodihallie8b0e8a2017-07-12 10:01:31 -0500208 writeUserdata(
209 table.partitions[numParts],
210 std::stoul(match[VERSION_MATCH].str(), nullptr, 16) <<
211 versionShift, // For eg, convert "80" to 0x80000000
212 match.suffix().str());
Deepak Kodihalli393821d2017-04-28 04:44:38 -0500213 table.partitions[numParts].checksum =
214 details::checksum(table.partitions[numParts].data);
215
216 ++numParts;
217 }
218 }
219}
220
221const pnor_partition& Table::partition(size_t offset) const
222{
223 const decltype(auto) table = getNativeTable();
Deepak Kodihallid1d79302017-07-11 23:01:39 -0500224 size_t offt = offset / blockSize;
Deepak Kodihalli393821d2017-04-28 04:44:38 -0500225
226 for (decltype(numParts) i{}; i < numParts; ++i)
227 {
228 if ((offt >= table.partitions[i].data.base) &&
229 (offt < (table.partitions[i].data.base +
230 table.partitions[i].data.size)))
231 {
232 return table.partitions[i];
233 }
234 }
235
Andrew Jefferye5707402018-02-02 14:39:36 +1030236 MSG_ERR("Partition corresponding to offset %zu not found", offset);
Jayanth Othayoth59ce0992017-10-27 00:45:53 -0500237 elog<InternalFailure>();
238
Deepak Kodihalli393821d2017-04-28 04:44:38 -0500239 static pnor_partition p{};
240 return p;
241}
242
Deepak Kodihalli8a899692017-07-11 23:17:19 -0500243const pnor_partition& Table::partition(const std::string& name) const
244{
245 const decltype(auto) table = getNativeTable();
246
247 for (decltype(numParts) i{}; i < numParts; ++i)
248 {
249 if (name == table.partitions[i].data.name)
250 {
251 return table.partitions[i];
252 }
253 }
254
255 MSG_ERR("Partition %s not found", name.c_str());
Marri Devender Rao08b0a892017-11-08 03:38:27 -0600256 log<level::ERR>("Table::partition partition not found ",
257 entry("PARTITION_NAME=%s", name.c_str()));
Deepak Kodihalli8a899692017-07-11 23:17:19 -0500258 elog<InternalFailure>();
259 static pnor_partition p{};
260 return p;
261}
262
Deepak Kodihalli393821d2017-04-28 04:44:38 -0500263} // namespace partition
264
265PartitionTable endianFixup(const PartitionTable& in)
266{
267 PartitionTable out;
268 out.resize(in.size());
269 auto src = reinterpret_cast<const pnor_partition_table*>(in.data());
270 auto dst = reinterpret_cast<pnor_partition_table*>(out.data());
271
272 dst->data.magic = htobe32(src->data.magic);
273 dst->data.version = htobe32(src->data.version);
274 dst->data.size = htobe32(src->data.size);
275 dst->data.entry_size = htobe32(src->data.entry_size);
276 dst->data.entry_count = htobe32(src->data.entry_count);
277 dst->data.block_size = htobe32(src->data.block_size);
278 dst->data.block_count = htobe32(src->data.block_count);
Deepak Kodihallib9cdcd22017-07-12 08:14:48 -0500279 dst->checksum = details::checksum(dst->data);
Deepak Kodihalli393821d2017-04-28 04:44:38 -0500280
281 for (decltype(src->data.entry_count) i{}; i < src->data.entry_count; ++i)
282 {
283 auto psrc = &src->partitions[i];
284 auto pdst = &dst->partitions[i];
285 strncpy(pdst->data.name, psrc->data.name, PARTITION_NAME_MAX);
286 // Just to be safe
287 pdst->data.name[PARTITION_NAME_MAX] = '\0';
288 pdst->data.base = htobe32(psrc->data.base);
289 pdst->data.size = htobe32(psrc->data.size);
290 pdst->data.pid = htobe32(psrc->data.pid);
291 pdst->data.id = htobe32(psrc->data.id);
292 pdst->data.type = htobe32(psrc->data.type);
293 pdst->data.flags = htobe32(psrc->data.flags);
294 pdst->data.actual = htobe32(psrc->data.actual);
295 for (size_t j = 0; j < PARTITION_USER_WORDS; ++j)
296 {
297 pdst->data.user.data[j] = htobe32(psrc->data.user.data[j]);
298 }
Deepak Kodihallib9cdcd22017-07-12 08:14:48 -0500299 pdst->checksum = details::checksum(pdst->data);
Deepak Kodihalli393821d2017-04-28 04:44:38 -0500300 }
301
302 return out;
303}
304
305} // namespace virtual_pnor
306} // namespace openpower