Fix LiveUpdate comparison issue with partitions, cleanup

Author: fwsGonzo

lib/LiveUpdate/liveupdate.hpp

@@ -140,14 +140,13 @@ struct Storage
   // store a TCP connection
   void add_connection(uid, Connection_ptr);
 
-  Storage(storage_header& sh) : hdr(sh) {}
-  void add_vector (uid, const void*, size_t count, size_t element_size);
-  void add_string_vector (uid, const std::vector<std::string>&);
-
   // markers are used to delineate the end of variable-length structures
   void put_marker(uid);
 
+  Storage(storage_header& sh) : hdr(sh) {}
 private:
+  void add_vector (uid, const void*, size_t count, size_t element_size);
+  void add_string_vector (uid, const std::vector<std::string>&);
   storage_header& hdr;
 };
 

lib/LiveUpdate/partition.cpp

@@ -46,7 +46,7 @@ int storage_header::find_partition(const char* key)
   for (uint32_t p = 0; p < this->partitions; p++)
   {
     auto& part = ptable.at(p);
-    if (strncmp(part.name, key, sizeof(part.name)))
+    if (strncmp(part.name, key, sizeof(part.name)) == 0)
     {
       uint32_t chsum = part.generate_checksum(this->vla);
       if (part.crc == chsum) {
@@ -69,6 +69,6 @@ void storage_header::finish_partition(int p)
 void storage_header::zero_partition(int p)
 {
   auto& part = ptable.at(p);
-  memset(&vla[part.offset], 0, part.length);
+  memset(&this->vla[part.offset], 0, part.length);
   memset(&part, 0, sizeof(partition_header));
 }

lib/LiveUpdate/resume.cpp

@@ -34,7 +34,7 @@ extern char* heap_end;
 
 namespace liu
 {
-static void resume_begin(storage_header&, const char*, LiveUpdate::resume_func);
+static void resume_begin(storage_header&, std::string, LiveUpdate::resume_func);
 static std::map<uint16_t, LiveUpdate::resume_func> resume_funcs;
 
 bool LiveUpdate::is_resumable()
@@ -66,17 +66,21 @@ void LiveUpdate::resume(std::string key, resume_func func)
 		     (long int) (heap_end - (char*) location));
     throw std::runtime_error("LiveUpdate storage area inside heap");
   }
-  resume_helper(location, key, func);
+  resume_helper(location, std::move(key), func);
 }
 void LiveUpdate::resume_from_heap(void* location, std::string key, LiveUpdate::resume_func func)
 {
-  resume_helper(location, key, func);
+  resume_helper(location, std::move(key), func);
 }
 
-void resume_begin(storage_header& storage, const char* key, LiveUpdate::resume_func func)
+void resume_begin(storage_header& storage, std::string key, LiveUpdate::resume_func func)
 {
-  int p = storage.find_partition(key);
-  LPRINT("* Resuming from partition %d\n", p);
+  if (key.empty())
+      throw std::length_error("LiveUpdate partition key cannot be an empty string");
+
+  int p = storage.find_partition(key.c_str());
+  LPRINT("* Resuming from partition %d at %p from %p\n",
+        p, storage.begin(p), &storage);
 
   /// restore each entry one by one, calling registered handlers
   for (auto* ptr = storage.begin(p); ptr->type != TYPE_END;)

lib/LiveUpdate/storage.cpp

@@ -108,7 +108,7 @@ void storage_header::add_string_vector(uint16_t id, const std::vector<std::strin
 }
 void storage_header::add_end()
 {
-  auto& ent = create_entry(TYPE_END);
+  auto& ent = create_entry(TYPE_END, 0, 0);
 
   // test against heap max
   uintptr_t storage_end = (uintptr_t) ent.vla;
@@ -178,11 +178,8 @@ storage_entry* storage_header::next(storage_entry* ptr)
   return ptr->next();
 }
 
-storage_entry::storage_entry(int16_t t, uint16_t ID, int v)
-  : type(t), id(ID), len(v) {}
-// used for last entry, for the most part
-storage_entry::storage_entry(int16_t t)
-  : type(t), id(0), len(0)  {}
+storage_entry::storage_entry(int16_t t, uint16_t ID, int L)
+  : type(t), id(ID), len(L) {}
 
 storage_entry* storage_entry::next() const noexcept
 {

lib/LiveUpdate/storage.hpp

@@ -60,7 +60,6 @@ struct varseg_entry
 struct storage_entry
 {
   storage_entry(int16_t type, uint16_t id, int length);
-  storage_entry(int16_t type);
 
   int16_t   type = TYPE_END;
   uint16_t  id   = 0;

lib/LiveUpdate/update.cpp

@@ -273,13 +273,13 @@ size_t update_store_data(void* location, const buffer_t* blob)
   new (location) storage_header();
   auto* storage = (storage_header*) location;
 
+  Storage wrapper(*storage);
   /// callback for storing stuff, if provided
   for (const auto& pair : storage_callbacks)
   {
     // create partition
     int p = storage->create_partition(pair.first);
     // run serialization process
-    Storage wrapper {*storage};
     pair.second(wrapper, blob);
     // add end for partition
     storage->finish_partition(p);

src/kernel/os.cpp

@@ -76,7 +76,7 @@ std::string OS::arch_str_ = ARCH;
 void* OS::liveupdate_storage_area() noexcept
 {
   // Default: 32MB below heap_max
-  return (void*) (OS::heap_max() - 0x2000000);
+  return (void*) (OS::heap_max() & 0xFFFFFFF0 - 0x2000000);
 }
 
 const std::string& OS::cmdline_args() noexcept