Revert "Revert "Add pretty-printing for liblp types""

base/cvd/cuttlefish/host/commands/assemble_cvd/android_build/BUILD.bazel

@@ -180,7 +180,9 @@ cf_cc_library(
     deps = [
         "//cuttlefish/common/libs/fs",
         "//cuttlefish/host/commands/assemble_cvd/android_build",
+        "//cuttlefish/pretty/liblp",
         "//cuttlefish/result",
+        "@abseil-cpp//absl/log",
         "@abseil-cpp//absl/strings",
         "@android_system_core//:liblp",
         "@fmt",

base/cvd/cuttlefish/host/commands/assemble_cvd/android_build/super_image.cc

@@ -27,6 +27,7 @@
 #include <utility>
 #include <vector>
 
+#include "absl/log/log.h"
 #include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/strip.h"
@@ -35,6 +36,7 @@
 
 #include "cuttlefish/common/libs/fs/shared_fd.h"
 #include "cuttlefish/host/commands/assemble_cvd/android_build/android_build.h"
+#include "cuttlefish/pretty/liblp/liblp.h"
 #include "cuttlefish/result/result.h"
 
 namespace cuttlefish {
@@ -221,6 +223,8 @@ Result<std::unique_ptr<AndroidBuild>> SuperImageAsBuild(AndroidBuild& build) {
   std::unique_ptr<android::fs_mgr::LpMetadata> lp_metadata =
       CF_EXPECT(SuperImageFromAndroidBuild(build));
 
+  VLOG(0) << Pretty(*lp_metadata);
+
   auto super_build =
       std::make_unique<SuperImageAsBuildImpl>(build, std::move(lp_metadata));
 

base/cvd/cuttlefish/pretty/liblp/BUILD.bazel

@@ -0,0 +1,45 @@
+load("//cuttlefish/bazel:rules.bzl", "cf_cc_library")
+
+package(
+    default_visibility = ["//:android_cuttlefish"],
+)
+
+cf_cc_library(
+    name = "builder",
+    srcs = ["builder.cc"],
+    hdrs = ["builder.h"],
+    deps = [
+        "//cuttlefish/pretty",
+        "//cuttlefish/pretty:string",
+        "//cuttlefish/pretty:struct",
+        "//cuttlefish/pretty:unique_ptr",
+        "//cuttlefish/pretty:vector",
+        "@android_system_core//:liblp",
+    ],
+)
+
+cf_cc_library(
+    name = "liblp",
+    srcs = ["liblp.cc"],
+    hdrs = ["liblp.h"],
+    deps = [
+        "//cuttlefish/pretty",
+        "//cuttlefish/pretty:struct",
+        "//cuttlefish/pretty:vector",
+        "//cuttlefish/pretty/liblp:metadata_format",
+        "@android_system_core//:liblp",
+    ],
+)
+
+cf_cc_library(
+    name = "metadata_format",
+    srcs = ["metadata_format.cc"],
+    hdrs = ["metadata_format.h"],
+    deps = [
+        "//cuttlefish/pretty",
+        "//cuttlefish/pretty:string",
+        "//cuttlefish/pretty:struct",
+        "//cuttlefish/pretty:vector",
+        "@android_system_core//:liblp",
+    ],
+)

base/cvd/cuttlefish/pretty/liblp/builder.cc

@@ -0,0 +1,86 @@
+//
+// Copyright (C) 2026 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 "cuttlefish/pretty/liblp/builder.h"
+
+#include "liblp/builder.h"
+
+#include "cuttlefish/pretty/pretty.h"
+#include "cuttlefish/pretty/string.h"
+#include "cuttlefish/pretty/struct.h"
+#include "cuttlefish/pretty/unique_ptr.h"
+#include "cuttlefish/pretty/vector.h"
+
+namespace cuttlefish {
+
+using android::fs_mgr::Extent;
+using android::fs_mgr::ExtentType;
+using android::fs_mgr::Interval;
+using android::fs_mgr::LinearExtent;
+using android::fs_mgr::Partition;
+using android::fs_mgr::PartitionGroup;
+using android::fs_mgr::ZeroExtent;
+
+PrettyStruct Pretty(const Extent& extent, PrettyAdlPlaceholder) {
+  switch (extent.GetExtentType()) {
+    case ExtentType::kZero:
+      return Pretty(static_cast<const ZeroExtent&>(extent));
+    case ExtentType::kLinear:
+      return Pretty(static_cast<const LinearExtent&>(extent));
+    default:
+      return PrettyStruct("Extent")
+          .Member("GetExtentType", extent.GetExtentType())
+          .Member("num_sectors", extent.num_sectors());
+  }
+}
+
+PrettyStruct Pretty(const LinearExtent& linear_extent, PrettyAdlPlaceholder) {
+  return PrettyStruct("LinearExtent")
+      .Member("physical_sector", linear_extent.physical_sector())
+      .Member("end_sector", linear_extent.end_sector())
+      .Member("device_index", linear_extent.device_index())
+      .Member("num_sectors", linear_extent.num_sectors());
+}
+
+PrettyStruct Pretty(const ZeroExtent& zero_extent, PrettyAdlPlaceholder) {
+  return PrettyStruct("ZeroExtent")
+      .Member("num_sectors", zero_extent.num_sectors());
+}
+
+PrettyStruct Pretty(const PartitionGroup& partition_group,
+                    PrettyAdlPlaceholder) {
+  return PrettyStruct("partition_group")
+      .Member("name", partition_group.name())
+      .Member("maximum_size", partition_group.maximum_size());
+}
+
+PrettyStruct Pretty(const Partition& partition, PrettyAdlPlaceholder) {
+  return PrettyStruct("Partition")
+      .Member("BytesOnDisk", partition.BytesOnDisk())
+      .Member("name", partition.name())
+      .Member("group_name", partition.group_name())
+      .Member("attributes", partition.attributes())
+      .Member("extents", partition.extents())
+      .Member("size", partition.size());
+}
+
+PrettyStruct Pretty(const Interval& interval, PrettyAdlPlaceholder) {
+  return PrettyStruct("Interval")
+      .Member("device_index", interval.device_index)
+      .Member("start", interval.start)
+      .Member("end", interval.end);
+}
+
+}  // namespace cuttlefish

base/cvd/cuttlefish/pretty/liblp/builder.h

@@ -0,0 +1,43 @@
+//
+// Copyright (C) 2026 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.
+
+#pragma once
+
+#include "liblp/builder.h"
+
+#include "cuttlefish/pretty/pretty.h"
+#include "cuttlefish/pretty/struct.h"
+
+namespace cuttlefish {
+
+PrettyStruct Pretty(const android::fs_mgr::Extent&,
+                    PrettyAdlPlaceholder unused = PrettyAdlPlaceholder());
+
+PrettyStruct Pretty(const android::fs_mgr::LinearExtent&,
+                    PrettyAdlPlaceholder unused = PrettyAdlPlaceholder());
+
+PrettyStruct Pretty(const android::fs_mgr::ZeroExtent&,
+                    PrettyAdlPlaceholder unused = PrettyAdlPlaceholder());
+
+PrettyStruct Pretty(const android::fs_mgr::PartitionGroup&,
+                    PrettyAdlPlaceholder unused = PrettyAdlPlaceholder());
+
+PrettyStruct Pretty(const android::fs_mgr::Partition&,
+                    PrettyAdlPlaceholder unused = PrettyAdlPlaceholder());
+
+PrettyStruct Pretty(const android::fs_mgr::Interval&,
+                    PrettyAdlPlaceholder unused = PrettyAdlPlaceholder());
+
+}  // namespace cuttlefish

base/cvd/cuttlefish/pretty/liblp/liblp.cc

@@ -0,0 +1,38 @@
+//
+// Copyright (C) 2026 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 "cuttlefish/pretty/liblp/liblp.h"
+
+#include "liblp/liblp.h"
+
+#include "cuttlefish/pretty/liblp/metadata_format.h"
+#include "cuttlefish/pretty/pretty.h"
+#include "cuttlefish/pretty/struct.h"
+#include "cuttlefish/pretty/vector.h"
+
+namespace cuttlefish {
+
+PrettyStruct Pretty(const android::fs_mgr::LpMetadata& metadata,
+                    PrettyAdlPlaceholder) {
+  return PrettyStruct("LpMetadata")
+      .Member("geometry", metadata.geometry)
+      .Member("header", metadata.header)
+      .Member("partitions", metadata.partitions)
+      .Member("extents", metadata.extents)
+      .Member("groups", metadata.groups)
+      .Member("block_devices", metadata.block_devices);
+}
+
+}  // namespace cuttlefish

base/cvd/cuttlefish/pretty/liblp/liblp.h

@@ -0,0 +1,28 @@
+//
+// Copyright (C) 2026 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.
+
+#pragma once
+
+#include "liblp/liblp.h"
+
+#include "cuttlefish/pretty/pretty.h"
+#include "cuttlefish/pretty/struct.h"
+
+namespace cuttlefish {
+
+PrettyStruct Pretty(const android::fs_mgr::LpMetadata&,
+                    PrettyAdlPlaceholder unused = PrettyAdlPlaceholder());
+
+}  // namespace cuttlefish

base/cvd/cuttlefish/pretty/liblp/metadata_format.cc

@@ -0,0 +1,116 @@
+//
+// Copyright (C) 2026 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 "cuttlefish/pretty/liblp/metadata_format.h"
+
+#include "liblp/liblp.h"
+#include "liblp/metadata_format.h"
+
+#include "cuttlefish/pretty/pretty.h"
+#include "cuttlefish/pretty/string.h"
+#include "cuttlefish/pretty/struct.h"
+#include "cuttlefish/pretty/vector.h"
+
+namespace cuttlefish {
+
+PrettyStruct Pretty(const LpMetadataGeometry& geometry, PrettyAdlPlaceholder) {
+  std::vector<uint8_t> checksum(
+      geometry.checksum,
+      geometry.checksum + (sizeof(geometry.checksum) / sizeof(uint8_t)));
+  return PrettyStruct("LpMetadataGeometry")
+      .Member("magic", geometry.magic)
+      .Member("struct_size", geometry.struct_size)
+      .Member("checksum", checksum)
+      .Member("metadata_max_size", geometry.metadata_max_size)
+      .Member("metadata_slot_count", geometry.metadata_slot_count)
+      .Member("logical_block_size", geometry.logical_block_size);
+}
+
+PrettyStruct Pretty(const LpMetadataTableDescriptor& metadata_table_descriptor,
+                    PrettyAdlPlaceholder) {
+  return PrettyStruct("LpMetadataTableDescriptor")
+      .Member("offset", metadata_table_descriptor.offset)
+      .Member("num_entries", metadata_table_descriptor.num_entries)
+      .Member("entry_size", metadata_table_descriptor.entry_size);
+}
+
+PrettyStruct Pretty(const LpMetadataHeader& metadata_header,
+                    PrettyAdlPlaceholder) {
+  std::vector<uint8_t> header_checksum(
+      metadata_header.header_checksum,
+      metadata_header.header_checksum +
+          (sizeof(metadata_header.header_checksum) / sizeof(uint8_t)));
+  std::vector<uint8_t> tables_checksum(
+      metadata_header.tables_checksum,
+      metadata_header.tables_checksum +
+          (sizeof(metadata_header.tables_checksum) / sizeof(uint8_t)));
+  return PrettyStruct("LpMetadataHeader")
+      .Member("magic", metadata_header.magic)
+      .Member("major_version", metadata_header.major_version)
+      .Member("minor_version", metadata_header.minor_version)
+      .Member("header_size", metadata_header.header_size)
+      .Member("header_checksum", header_checksum)
+      .Member("tables_size", metadata_header.tables_size)
+      .Member("tables_checksum", tables_checksum)
+      .Member("partitions", metadata_header.partitions)
+      .Member("extents", metadata_header.extents)
+      .Member("groups", metadata_header.groups)
+      .Member("block_devices", metadata_header.block_devices)
+      .Member("flags", metadata_header.flags);
+}
+
+PrettyStruct Pretty(const LpMetadataPartition& metadata_partition,
+                    PrettyAdlPlaceholder) {
+  return PrettyStruct("LpMetadataPartition")
+      .Member("name", android::fs_mgr::GetPartitionName(metadata_partition))
+      .Member("attributes", metadata_partition.attributes)
+      .Member("first_extent_index", metadata_partition.first_extent_index)
+      .Member("num_extents", metadata_partition.num_extents)
+      .Member("group_index", metadata_partition.group_index);
+}
+
+PrettyStruct Pretty(const LpMetadataExtent& metadata_extent,
+                    PrettyAdlPlaceholder) {
+  return PrettyStruct("LpMetadataExtent")
+      .Member("num_sectors", metadata_extent.num_sectors)
+      .Member("target_type", metadata_extent.target_type)
+      .Member("target_data", metadata_extent.target_data)
+      .Member("target_source", metadata_extent.target_source);
+}
+
+PrettyStruct Pretty(const LpMetadataPartitionGroup& metadata_partition_group,
+                    PrettyAdlPlaceholder) {
+  return PrettyStruct("LpMetadataPartitionGroup")
+      .Member("name",
+              android::fs_mgr::GetPartitionGroupName(metadata_partition_group))
+      .Member("flags", metadata_partition_group.flags)
+      .Member("maximum_size", metadata_partition_group.maximum_size);
+}
+
+PrettyStruct Pretty(const LpMetadataBlockDevice& block_device,
+                    PrettyAdlPlaceholder) {
+  std::string_view partition_name(
+      block_device.partition_name,
+      sizeof(block_device.partition_name) / sizeof(char));
+  return PrettyStruct("LpMetadataBlockDevice")
+      .Member("first_logical_sector", block_device.first_logical_sector)
+      .Member("alignment", block_device.alignment)
+      .Member("alignment_offset", block_device.alignment_offset)
+      .Member("size", block_device.size)
+      .Member("partition_name", partition_name)
+      .Member("flags", block_device.flags);
+}
+
+}  // namespace cuttlefish