From 504982424b1323cef778125c708a079f954833ef Mon Sep 17 00:00:00 2001 From: "A. Cody Schuffelen" Date: Fri, 16 Jan 2026 18:22:37 -0800 Subject: [PATCH] Revert "Revert "Add pretty-printing for liblp types"" This reverts commit 699b44de5a9129cde78e6d32d81f7b4bd119c1f3. --- .../assemble_cvd/android_build/BUILD.bazel | 2 + .../assemble_cvd/android_build/super_image.cc | 4 + base/cvd/cuttlefish/pretty/liblp/BUILD.bazel | 45 +++++++ base/cvd/cuttlefish/pretty/liblp/builder.cc | 86 +++++++++++++ base/cvd/cuttlefish/pretty/liblp/builder.h | 43 +++++++ base/cvd/cuttlefish/pretty/liblp/liblp.cc | 38 ++++++ base/cvd/cuttlefish/pretty/liblp/liblp.h | 28 +++++ .../pretty/liblp/metadata_format.cc | 116 ++++++++++++++++++ .../cuttlefish/pretty/liblp/metadata_format.h | 46 +++++++ 9 files changed, 408 insertions(+) create mode 100644 base/cvd/cuttlefish/pretty/liblp/BUILD.bazel create mode 100644 base/cvd/cuttlefish/pretty/liblp/builder.cc create mode 100644 base/cvd/cuttlefish/pretty/liblp/builder.h create mode 100644 base/cvd/cuttlefish/pretty/liblp/liblp.cc create mode 100644 base/cvd/cuttlefish/pretty/liblp/liblp.h create mode 100644 base/cvd/cuttlefish/pretty/liblp/metadata_format.cc create mode 100644 base/cvd/cuttlefish/pretty/liblp/metadata_format.h diff --git a/base/cvd/cuttlefish/host/commands/assemble_cvd/android_build/BUILD.bazel b/base/cvd/cuttlefish/host/commands/assemble_cvd/android_build/BUILD.bazel index 60fca45a8ae..38c52e5df12 100644 --- a/base/cvd/cuttlefish/host/commands/assemble_cvd/android_build/BUILD.bazel +++ b/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", diff --git a/base/cvd/cuttlefish/host/commands/assemble_cvd/android_build/super_image.cc b/base/cvd/cuttlefish/host/commands/assemble_cvd/android_build/super_image.cc index 6e470ce8b1e..8a42759268e 100644 --- a/base/cvd/cuttlefish/host/commands/assemble_cvd/android_build/super_image.cc +++ b/base/cvd/cuttlefish/host/commands/assemble_cvd/android_build/super_image.cc @@ -27,6 +27,7 @@ #include #include +#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> SuperImageAsBuild(AndroidBuild& build) { std::unique_ptr lp_metadata = CF_EXPECT(SuperImageFromAndroidBuild(build)); + VLOG(0) << Pretty(*lp_metadata); + auto super_build = std::make_unique(build, std::move(lp_metadata)); diff --git a/base/cvd/cuttlefish/pretty/liblp/BUILD.bazel b/base/cvd/cuttlefish/pretty/liblp/BUILD.bazel new file mode 100644 index 00000000000..1abacecfb14 --- /dev/null +++ b/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", + ], +) diff --git a/base/cvd/cuttlefish/pretty/liblp/builder.cc b/base/cvd/cuttlefish/pretty/liblp/builder.cc new file mode 100644 index 00000000000..409d64fb874 --- /dev/null +++ b/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(extent)); + case ExtentType::kLinear: + return Pretty(static_cast(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 diff --git a/base/cvd/cuttlefish/pretty/liblp/builder.h b/base/cvd/cuttlefish/pretty/liblp/builder.h new file mode 100644 index 00000000000..c0371eecc5c --- /dev/null +++ b/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 diff --git a/base/cvd/cuttlefish/pretty/liblp/liblp.cc b/base/cvd/cuttlefish/pretty/liblp/liblp.cc new file mode 100644 index 00000000000..3b1788d1753 --- /dev/null +++ b/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 diff --git a/base/cvd/cuttlefish/pretty/liblp/liblp.h b/base/cvd/cuttlefish/pretty/liblp/liblp.h new file mode 100644 index 00000000000..f8f1a5e6107 --- /dev/null +++ b/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 diff --git a/base/cvd/cuttlefish/pretty/liblp/metadata_format.cc b/base/cvd/cuttlefish/pretty/liblp/metadata_format.cc new file mode 100644 index 00000000000..dcdba5b3d96 --- /dev/null +++ b/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 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 header_checksum( + metadata_header.header_checksum, + metadata_header.header_checksum + + (sizeof(metadata_header.header_checksum) / sizeof(uint8_t))); + std::vector 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 diff --git a/base/cvd/cuttlefish/pretty/liblp/metadata_format.h b/base/cvd/cuttlefish/pretty/liblp/metadata_format.h new file mode 100644 index 00000000000..06294a0fd8f --- /dev/null +++ b/base/cvd/cuttlefish/pretty/liblp/metadata_format.h @@ -0,0 +1,46 @@ +// +// 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/metadata_format.h" + +#include "cuttlefish/pretty/pretty.h" +#include "cuttlefish/pretty/struct.h" + +namespace cuttlefish { + +PrettyStruct Pretty(const LpMetadataGeometry&, + PrettyAdlPlaceholder unused = PrettyAdlPlaceholder()); + +PrettyStruct Pretty(const LpMetadataTableDescriptor&, + PrettyAdlPlaceholder unused = PrettyAdlPlaceholder()); + +PrettyStruct Pretty(const LpMetadataHeader&, + PrettyAdlPlaceholder unused = PrettyAdlPlaceholder()); + +PrettyStruct Pretty(const LpMetadataPartition&, + PrettyAdlPlaceholder unused = PrettyAdlPlaceholder()); + +PrettyStruct Pretty(const LpMetadataExtent&, + PrettyAdlPlaceholder unused = PrettyAdlPlaceholder()); + +PrettyStruct Pretty(const LpMetadataPartitionGroup&, + PrettyAdlPlaceholder unused = PrettyAdlPlaceholder()); + +PrettyStruct Pretty(const LpMetadataBlockDevice&, + PrettyAdlPlaceholder unused = PrettyAdlPlaceholder()); + +} // namespace cuttlefish