misctrl: read message, incl 16kb flag

Add a misctrl specific message with its first use.
Future platform flags can go here for any purpose,
without needing to add separate utilities.

Check if a device has ever been in 16KB before so that
we are able to tell if 16KB causes any issues.

Bug: 317262681
Test: boot, bugreport
Change-Id: I21299ded1520020768462950713cbe49ca3c438f

bootloader_message/bootloader_message.cpp

@@ -325,6 +325,16 @@ bool WriteMiscKcmdlineMessage(const misc_kcmdline_message& message, std::string*
                                        offsetof(misc_system_space_layout, kcmdline_message), err);
 }
 
+bool ReadMiscControlMessage(misc_control_message* message, std::string* err) {
+  return ReadMiscPartitionSystemSpace(message, sizeof(*message),
+                                      offsetof(misc_system_space_layout, control_message), err);
+}
+
+bool WriteMiscControlMessage(const misc_control_message& message, std::string* err) {
+  return WriteMiscPartitionSystemSpace(&message, sizeof(message),
+                                       offsetof(misc_system_space_layout, control_message), err);
+}
+
 bool CheckReservedSystemSpaceEmpty(bool* empty, std::string* err) {
   constexpr size_t kReservedSize = SYSTEM_SPACE_SIZE_IN_MISC - sizeof(misc_system_space_layout);
 

bootloader_message/include/bootloader_message/bootloader_message.h

@@ -107,6 +107,14 @@ struct misc_kcmdline_message {
   uint8_t reserved[51];
 } __attribute__((packed));
 
+// holds generic platform info, managed by misctrl
+struct misc_control_message {
+  uint8_t version;
+  uint32_t magic;
+  uint64_t misctrl_flags;
+  uint8_t reserved[51];
+} __attribute__((packed));
+
 #define MISC_VIRTUAL_AB_MESSAGE_VERSION 2
 #define MISC_VIRTUAL_AB_MAGIC_HEADER 0x56740AB0
 
@@ -127,6 +135,10 @@ struct misc_kcmdline_message {
 #define MISC_KCMDLINE_MAGIC_HEADER 0x6ab5110c
 #define MISC_KCMDLINE_BINDER_RUST 0x1
 
+#define MISC_CONTROL_MESSAGE_VERSION 1
+#define MISC_CONTROL_MAGIC_HEADER 0x736d6f72
+#define MISC_CONTROL_16KB_BEFORE 0x1
+
 #if (__STDC_VERSION__ >= 201112L) || defined(__cplusplus)
 static_assert(sizeof(struct misc_virtual_ab_message) == 64,
               "struct misc_virtual_ab_message has wrong size");
@@ -134,6 +146,8 @@ static_assert(sizeof(struct misc_memtag_message) == 64,
               "struct misc_memtag_message has wrong size");
 static_assert(sizeof(struct misc_kcmdline_message) == 64,
               "struct misc_kcmdline_message has wrong size");
+static_assert(sizeof(struct misc_control_message) == 64,
+              "struct misc_control_message has wrong size");
 #endif
 
 // This struct is not meant to be used directly, rather, it is to make
@@ -142,8 +156,14 @@ struct misc_system_space_layout {
   misc_virtual_ab_message virtual_ab_message;
   misc_memtag_message memtag_message;
   misc_kcmdline_message kcmdline_message;
+  misc_control_message control_message;
 } __attribute__((packed));
 
+#if (__STDC_VERSION__ >= 201112L) || defined(__cplusplus)
+static_assert(sizeof(struct misc_system_space_layout) % 64 == 0,
+              "prefer to extend by 64 byte chunks, for consistency");
+#endif
+
 #ifdef __cplusplus
 
 #include <string>
@@ -217,6 +237,10 @@ bool WriteMiscMemtagMessage(const misc_memtag_message& message, std::string* err
 bool ReadMiscKcmdlineMessage(misc_kcmdline_message* message, std::string* err);
 bool WriteMiscKcmdlineMessage(const misc_kcmdline_message& message, std::string* err);
 
+// Read or write the kcmdline message from system space in /misc.
+bool ReadMiscControlMessage(misc_control_message* message, std::string* err);
+bool WriteMiscControlMessage(const misc_control_message& message, std::string* err);
+
 // Check reserved system space.
 bool CheckReservedSystemSpaceEmpty(bool* empty, std::string* err);
 

bootloader_message/misctrl_main.cpp

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <android-base/properties.h>
 #include <bootloader_message/bootloader_message.h>
 #include <log/log.h>
 
@@ -36,6 +37,45 @@ static void log(const char* fmt, ...) {
   va_end(vb);
 }
 
+static int check_control_message() {
+  misc_control_message m;
+  std::string err;
+  if (!ReadMiscControlMessage(&m, &err)) {
+    log("Could not read misctrl message: %s", err.c_str());
+    return 1;
+  }
+
+  if (m.magic != MISC_CONTROL_MAGIC_HEADER || m.version != MISC_CONTROL_MESSAGE_VERSION) {
+    log("misctrl message invalid, resetting it");
+    m = { .version = MISC_CONTROL_MESSAGE_VERSION,
+          .magic = MISC_CONTROL_MAGIC_HEADER,
+          .misctrl_flags = 0 };
+  }
+
+  int res = 0;
+
+  const size_t ps = getpagesize();
+
+  if (ps != 4096 && ps != 16384) {
+    log("Unrecognized page size: %zu", ps);
+    res = 1;
+  }
+
+  if (ps == 16384) {
+    m.misctrl_flags |= MISC_CONTROL_16KB_BEFORE;
+  }
+
+  bool before_16kb = m.misctrl_flags & MISC_CONTROL_16KB_BEFORE;
+  res |= android::base::SetProperty("ro.misctrl.16kb_before", before_16kb ? "1" : "0");
+
+  if (!WriteMiscControlMessage(m, &err)) {
+    log("Could not write misctrl message: %s", err.c_str());
+    res |= 1;
+  }
+
+  return res;
+}
+
 static int check_reserved_space() {
   bool empty;
   std::string err;
@@ -57,5 +97,8 @@ static int check_reserved_space() {
 }
 
 int main() {
-  return check_reserved_space();
+  int err = 0;
+  err |= check_control_message();
+  err |= check_reserved_space();
+  return err;
 }