Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Unverified Commit 4712436a authored by Michael Bestas's avatar Michael Bestas
Browse files

Merge tag 'android-14.0.0_r50' into staging/lineage-21.0_merge-android-14.0.0_r50 

Android 14.0.0 Release 50 (AP2A.240605.024)

# -----BEGIN PGP SIGNATURE-----
#
# iF0EABECAB0WIQRDQNE1cO+UXoOBCWTorT+BmrEOeAUCZmdzmgAKCRDorT+BmrEO
# eDmTAJ9QtL7JdJI9M5/AEPzezKZuFOwDUQCdEBtfylvKsSOyMu4JUnAx1b1jUgk=
# =GsKk
# -----END PGP SIGNATURE-----
# gpg: Signature made Tue Jun 11 00:43:54 2024 EEST
# gpg:                using DSA key 4340D13570EF945E83810964E8AD3F819AB10E78
# gpg: Good signature from "The Android Open Source Project <initial-contribution@android.com>" [marginal]
# gpg: initial-contribution@android.com: Verified 2468 signatures in the past
#      2 years.  Encrypted 4 messages in the past 2 years.
# gpg: WARNING: This key is not certified with sufficiently trusted signatures!
# gpg:          It is not certain that the signature belongs to the owner.
# Primary key fingerprint: 4340 D135 70EF 945E 8381  0964 E8AD 3F81 9AB1 0E78

# By Kelvin Zhang (3) and others
# Via Automerger Merge Worker (24) and others
* tag 'android-14.0.0_r50':
  misctrl: use libbase combined logging
  misctrl: read message, incl 16kb flag
  intro misctrl
  Reland "Only format /data in recovery if user specified a new fstype"
  Add kcmdline bootloader message
  Revert "Only format /data in recovery if user specified a new fstype"
  Only format /data in recovery if user specified a new fstype
  Fix the problem of incremental OTA upgrade failure (recovery part)
  Add recovery flag to reformat /data

 Conflicts:
	install/include/install/wipe_data.h
	recovery.cpp

Change-Id: Iefa48a2c81c0ec726dc9798ac7a59b25f12dddde
parents a08daf08 5880e9e9

bootloader_message/Android.bp

+11 −0
Original line number Diff line number Diff line
@@ -40,6 +40,17 @@ cc_defaults { 
    export_include_dirs: ["include"],

}



cc_binary {

    name: "misctrl",

    shared_libs: [

        "libbase",

        "libbootloader_message",

        "liblog",

    ],

    init_rc: ["misctrl.rc"],

    srcs: ["misctrl_main.cpp"],

}



cc_library {

    name: "libbootloader_message",

    defaults: [

bootloader_message/bootloader_message.cpp

+38 −0
Original line number Diff line number Diff line
@@ -26,6 +26,7 @@ 
#include <vector>



#include <android-base/file.h>

#include <android-base/hex.h>

#include <android-base/properties.h>

#include <android-base/stringprintf.h>

#include <android-base/unique_fd.h>
@@ -319,6 +320,43 @@ bool WriteMiscMemtagMessage(const misc_memtag_message& message, std::string* err 
                                       offsetof(misc_system_space_layout, memtag_message), err);

}



bool ReadMiscKcmdlineMessage(misc_kcmdline_message* message, std::string* err) {

  return ReadMiscPartitionSystemSpace(message, sizeof(*message),

                                      offsetof(misc_system_space_layout, kcmdline_message), err);

}



bool WriteMiscKcmdlineMessage(const misc_kcmdline_message& message, std::string* err) {

  return WriteMiscPartitionSystemSpace(&message, sizeof(message),

                                       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);



  uint8_t space[kReservedSize];

  if (!ReadMiscPartitionSystemSpace(&space, kReservedSize, sizeof(misc_system_space_layout), err)) {

    return false;

  }



  *empty = space[0] == 0 && 0 == memcmp(space, space + 1, kReservedSize - 1);



  if (!*empty) {

    *err = android::base::HexString(space, kReservedSize);

  }



  return true;

}



extern "C" bool write_reboot_bootloader(void) {

  std::string err;

  return write_reboot_bootloader(&err);

bootloader_message/include/bootloader_message/bootloader_message.h

+46 −0
Original line number Diff line number Diff line
@@ -100,6 +100,21 @@ struct misc_memtag_message { 
  uint8_t reserved[55];

} __attribute__((packed));



struct misc_kcmdline_message {

  uint8_t version;

  uint32_t magic;

  uint64_t kcmdline_flags;

  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
@@ -116,11 +131,23 @@ struct misc_memtag_message { 
// See system/extras/mtectrl in AOSP for more information.

#define MISC_MEMTAG_MODE_FORCED 0x20



#define MISC_KCMDLINE_MESSAGE_VERSION 1

#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");

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
@@ -128,8 +155,15 @@ static_assert(sizeof(struct misc_memtag_message) == 64, 
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>
@@ -198,6 +232,18 @@ bool WriteMiscVirtualAbMessage(const misc_virtual_ab_message& message, std::stri 
// Read or write the memtag message from system space in /misc.

bool ReadMiscMemtagMessage(misc_memtag_message* message, std::string* err);

bool WriteMiscMemtagMessage(const misc_memtag_message& message, std::string* err);



// Read or write the kcmdline message from system space in /misc.

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);



#else



#include <stdbool.h>

bootloader_message/misctrl.rc

0 → 100644
+4 −0
Original line number Diff line number Diff line 
service misctrl /system/bin/misctrl

    user root # for misc partition access

    class core

    oneshot

bootloader_message/misctrl_main.cpp

0 → 100644
+91 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2024 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

#include <android-base/logging.h>

#include <android-base/properties.h>

#include <bootloader_message/bootloader_message.h>

#include <log/log.h>



#include <string>



#include <cstdio>



static int check_control_message() {

  misc_control_message m;

  std::string err;

  if (!ReadMiscControlMessage(&m, &err)) {

    LOG(ERROR) << "Could not read misctrl message: " << err.c_str();

    return 1;

  }



  if (m.magic != MISC_CONTROL_MAGIC_HEADER || m.version != MISC_CONTROL_MESSAGE_VERSION) {

    LOG(WARNING) << "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(ERROR) << "Unrecognized page size: " << 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(ERROR) << "Could not write misctrl message: " << err.c_str();

    res |= 1;

  }



  return res;

}



static int check_reserved_space() {

  bool empty;

  std::string err;

  bool success = CheckReservedSystemSpaceEmpty(&empty, &err);

  if (!success) {

    LOG(ERROR) << "Could not read reserved space: " << err.c_str();

    return 1;

  }

  LOG(INFO) << "System reserved space empty? " << empty;



  if (!err.empty()) {

    LOG(ERROR) << "Reserved misc space being used: " << err;

  }



  return empty ? 0 : 1;

}



int main(int argc, char** argv) {

  {

    using namespace android::base;

    (void)argc;

    InitLogging(argv, TeeLogger(LogdLogger(), &StderrLogger));

  }

  int err = 0;

  err |= check_control_message();

  err |= check_reserved_space();

  return err;

}