| /* | |
| * (C) Copyright 2013 Amlogic, Inc | |
| * | |
| * This file is used to get metadata from super partition | |
| * More detail to check the command "run readMetadata" usage | |
| * | |
| * xindong.xu@amlogic.com, | |
| * 2018-08-15 @ ShangHai | |
| * | |
| */ | |
| #include <common.h> | |
| #include <command.h> | |
| #include <environment.h> | |
| #include <malloc.h> | |
| #include <asm/byteorder.h> | |
| #include <config.h> | |
| #include <asm/arch/io.h> | |
| #include <emmc_partitions.h> | |
| #ifdef CONFIG_BOOTLOADER_CONTROL_BLOCK | |
| extern int store_read_ops( | |
| unsigned char *partition_name, | |
| unsigned char * buf, uint64_t off, uint64_t size); | |
| extern int store_write_ops( | |
| unsigned char *partition_name, | |
| unsigned char * buf, uint64_t off, uint64_t size); | |
| /* Magic signature for LpMetadataGeometry. */ | |
| #define LP_METADATA_GEOMETRY_MAGIC 0x616c4467 | |
| /* Space reserved for geometry information. */ | |
| #define LP_METADATA_GEOMETRY_SIZE 4096 | |
| #define LP_METADATA_HEADER_SIZE 124 | |
| #define SUPERBUF_SIZE 16384 | |
| /* Magic signature for LpMetadataHeader. */ | |
| #define LP_METADATA_HEADER_MAGIC 0x414C5030 | |
| /* Current metadata version. */ | |
| #define LP_METADATA_MAJOR_VERSION 10 | |
| #define LP_METADATA_MINOR_VERSION 0 | |
| /* Attributes for the LpMetadataPartition::attributes field. | |
| * | |
| * READONLY - The partition should not be considered writable. When used with | |
| * device mapper, the block device will be created as read-only. | |
| */ | |
| #define LP_PARTITION_ATTR_NONE 0x0 | |
| #define LP_PARTITION_ATTR_READONLY (1 << 0) | |
| /* This flag is only intended to be used with super_empty.img and super.img on | |
| * retrofit devices. On these devices there are A and B super partitions, and | |
| * we don't know ahead of time which slot the image will be applied to. | |
| * | |
| * If set, the partition name needs a slot suffix applied. The slot suffix is | |
| * determined by the metadata slot number (0 = _a, 1 = _b). | |
| */ | |
| #define LP_PARTITION_ATTR_SLOT_SUFFIXED (1 << 1) | |
| /* Mask that defines all valid attributes. */ | |
| #define LP_PARTITION_ATTRIBUTE_MASK (LP_PARTITION_ATTR_READONLY | LP_PARTITION_ATTR_SLOT_SUFFIXED) | |
| /* Default name of the physical partition that holds logical partition entries. | |
| * The layout of this partition will look like: | |
| * | |
| * +--------------------+ | |
| * | Disk Geometry | | |
| * +--------------------+ | |
| * | Geometry Backup | | |
| * +--------------------+ | |
| * | Metadata | | |
| * +--------------------+ | |
| * | Backup Metadata | | |
| * +--------------------+ | |
| * | Logical Partitions | | |
| * +--------------------+ | |
| */ | |
| #define LP_METADATA_DEFAULT_PARTITION_NAME "super" | |
| /* Size of a sector is always 512 bytes for compatibility with the Linux kernel. */ | |
| #define LP_SECTOR_SIZE 512 | |
| /* Amount of space reserved at the start of every super partition to avoid | |
| * creating an accidental boot sector. | |
| */ | |
| #define LP_PARTITION_RESERVED_BYTES 4096 | |
| /* This structure is stored at block 0 in the first 4096 bytes of the | |
| * partition, and again in the following block. It is never modified and | |
| * describes how logical partition information can be located. | |
| */ | |
| typedef struct LpMetadataGeometry { | |
| /* 0: Magic signature (LP_METADATA_GEOMETRY_MAGIC). */ | |
| uint32_t magic; | |
| /* 4: Size of the LpMetadataGeometry struct. */ | |
| uint32_t struct_size; | |
| /* 8: SHA256 checksum of this struct, with this field set to 0. */ | |
| uint8_t checksum[32]; | |
| /* 40: Maximum amount of space a single copy of the metadata can use. This | |
| * must be a multiple of LP_SECTOR_SIZE. | |
| */ | |
| uint32_t metadata_max_size; | |
| /* 44: Number of copies of the metadata to keep. For A/B devices, this | |
| * will be 2. For an A/B/C device, it would be 3, et cetera. For Non-A/B | |
| * it will be 1. A backup copy of each slot is kept, so if this is "2", | |
| * there will be four copies total. | |
| */ | |
| uint32_t metadata_slot_count; | |
| /* 48: Logical block size. This is the minimal alignment for partition and | |
| * extent sizes, and it must be a multiple of LP_SECTOR_SIZE. Note that | |
| * this must be equal across all LUNs that comprise the super partition, | |
| * and thus this field is stored in the geometry, not per-device. | |
| */ | |
| uint32_t logical_block_size; | |
| } __attribute__((packed)) LpMetadataGeometry; | |
| /* The logical partition metadata has a number of tables; they are described | |
| * in the header via the following structure. | |
| * | |
| * The size of the table can be computed by multiplying entry_size by | |
| * num_entries, and the result must not overflow a 32-bit signed integer. | |
| */ | |
| typedef struct LpMetadataTableDescriptor { | |
| /* 0: Location of the table, relative to end of the metadata header. */ | |
| uint32_t offset; | |
| /* 4: Number of entries in the table. */ | |
| uint32_t num_entries; | |
| /* 8: Size of each entry in the table, in bytes. */ | |
| uint32_t entry_size; | |
| } __attribute__((packed)) LpMetadataTableDescriptor; | |
| /* Binary format for the header of the logical partition metadata format. | |
| * | |
| * The format has three sections. The header must occur first, and the | |
| * proceeding tables may be placed in any order after. | |
| * | |
| * +-----------------------------------------+ | |
| * | Header data - fixed size | | |
| * +-----------------------------------------+ | |
| * | Partition table - variable size | | |
| * +-----------------------------------------+ | |
| * | Partition table extents - variable size | | |
| * +-----------------------------------------+ | |
| * | |
| * The "Header" portion is described by LpMetadataHeader. It will always | |
| * precede the other three blocks. | |
| * | |
| * All fields are stored in little-endian byte order when serialized. | |
| * | |
| * This struct is versioned; see the |major_version| and |minor_version| | |
| * fields. | |
| */ | |
| typedef struct LpMetadataHeader { | |
| /* 0: Four bytes equal to LP_METADATA_HEADER_MAGIC. */ | |
| uint32_t magic; | |
| /* 4: Version number required to read this metadata. If the version is not | |
| * equal to the library version, the metadata should be considered | |
| * incompatible. | |
| */ | |
| uint16_t major_version; | |
| /* 6: Minor version. A library supporting newer features should be able to | |
| * read metadata with an older minor version. However, an older library | |
| * should not support reading metadata if its minor version is higher. | |
| */ | |
| uint16_t minor_version; | |
| /* 8: The size of this header struct. */ | |
| uint32_t header_size; | |
| /* 12: SHA256 checksum of the header, up to |header_size| bytes, computed as | |
| * if this field were set to 0. | |
| */ | |
| uint8_t header_checksum[32]; | |
| /* 44: The total size of all tables. This size is contiguous; tables may not | |
| * have gaps in between, and they immediately follow the header. | |
| */ | |
| uint32_t tables_size; | |
| /* 48: SHA256 checksum of all table contents. */ | |
| uint8_t tables_checksum[32]; | |
| /* 80: Partition table descriptor. */ | |
| LpMetadataTableDescriptor partitions; | |
| /* 92: Extent table descriptor. */ | |
| LpMetadataTableDescriptor extents; | |
| /* 104: Updateable group descriptor. */ | |
| LpMetadataTableDescriptor groups; | |
| /* 116: Block device table. */ | |
| LpMetadataTableDescriptor block_devices; | |
| } __attribute__((packed)) LpMetadataHeader; | |
| /* This struct defines a logical partition entry, similar to what would be | |
| * present in a GUID Partition Table. | |
| */ | |
| typedef struct LpMetadataPartition { | |
| /* 0: Name of this partition in ASCII characters. Any unused characters in | |
| * the buffer must be set to 0. Characters may only be alphanumeric or _. | |
| * The name must include at least one ASCII character, and it must be unique | |
| * across all partition names. The length (36) is the same as the maximum | |
| * length of a GPT partition name. | |
| */ | |
| char name[36]; | |
| /* 36: Attributes for the partition (see LP_PARTITION_ATTR_* flags above). */ | |
| uint32_t attributes; | |
| /* 40: Index of the first extent owned by this partition. The extent will | |
| * start at logical sector 0. Gaps between extents are not allowed. | |
| */ | |
| uint32_t first_extent_index; | |
| /* 44: Number of extents in the partition. Every partition must have at | |
| * least one extent. | |
| */ | |
| uint32_t num_extents; | |
| /* 48: Group this partition belongs to. */ | |
| uint32_t group_index; | |
| } __attribute__((packed)) LpMetadataPartition; | |
| /* This extent is a dm-linear target, and the index is an index into the | |
| * LinearExtent table. | |
| */ | |
| #define LP_TARGET_TYPE_LINEAR 0 | |
| /* This extent is a dm-zero target. The index is ignored and must be 0. */ | |
| #define LP_TARGET_TYPE_ZERO 1 | |
| /* This struct defines an extent entry in the extent table block. */ | |
| typedef struct LpMetadataExtent { | |
| /* 0: Length of this extent, in 512-byte sectors. */ | |
| uint64_t num_sectors; | |
| /* 8: Target type for device-mapper (see LP_TARGET_TYPE_* values). */ | |
| uint32_t target_type; | |
| /* 12: Contents depends on target_type. | |
| * | |
| * LINEAR: The sector on the physical partition that this extent maps onto. | |
| * ZERO: This field must be 0. | |
| */ | |
| uint64_t target_data; | |
| /* 20: Contents depends on target_type. | |
| * | |
| * LINEAR: Must be an index into the block devices table. | |
| * ZERO: This field must be 0. | |
| */ | |
| uint32_t target_source; | |
| } __attribute__((packed)) LpMetadataExtent; | |
| /* This struct defines an entry in the groups table. Each group has a maximum | |
| * size, and partitions in a group must not exceed that size. There is always | |
| * a "default" group of unlimited size, which is used when not using update | |
| * groups or when using overlayfs or fastbootd. | |
| */ | |
| typedef struct LpMetadataPartitionGroup { | |
| /* 0: Name of this group. Any unused characters must be 0. */ | |
| char name[36]; | |
| /* 36: Flags (see LP_GROUP_*). */ | |
| uint32_t flags; | |
| /* 40: Maximum size in bytes. If 0, the group has no maximum size. */ | |
| uint64_t maximum_size; | |
| } __attribute__((packed)) LpMetadataPartitionGroup; | |
| /* This flag is only intended to be used with super_empty.img and super.img on | |
| * retrofit devices. If set, the group needs a slot suffix to be interpreted | |
| * correctly. The suffix is automatically applied by ReadMetadata(). | |
| */ | |
| #define LP_GROUP_SLOT_SUFFIXED (1 << 0) | |
| /* This struct defines an entry in the block_devices table. There must be at | |
| * least one device, and the first device must represent the partition holding | |
| * the super metadata. | |
| */ | |
| typedef struct LpMetadataBlockDevice { | |
| /* 0: First usable sector for allocating logical partitions. this will be | |
| * the first sector after the initial geometry blocks, followed by the | |
| * space consumed by metadata_max_size*metadata_slot_count*2. | |
| */ | |
| uint64_t first_logical_sector; | |
| /* 8: Alignment for defining partitions or partition extents. For example, | |
| * an alignment of 1MiB will require that all partitions have a size evenly | |
| * divisible by 1MiB, and that the smallest unit the partition can grow by | |
| * is 1MiB. | |
| * | |
| * Alignment is normally determined at runtime when growing or adding | |
| * partitions. If for some reason the alignment cannot be determined, then | |
| * this predefined alignment in the geometry is used instead. By default | |
| * it is set to 1MiB. | |
| */ | |
| uint32_t alignment; | |
| /* 12: Alignment offset for "stacked" devices. For example, if the "super" | |
| * partition itself is not aligned within the parent block device's | |
| * partition table, then we adjust for this in deciding where to place | |
| * |first_logical_sector|. | |
| * | |
| * Similar to |alignment|, this will be derived from the operating system. | |
| * If it cannot be determined, it is assumed to be 0. | |
| */ | |
| uint32_t alignment_offset; | |
| /* 16: Block device size, as specified when the metadata was created. This | |
| * can be used to verify the geometry against a target device. | |
| */ | |
| uint64_t size; | |
| /* 24: Partition name in the GPT. Any unused characters must be 0. */ | |
| char partition_name[36]; | |
| /* 60: Flags (see LP_BLOCK_DEVICE_* flags below). */ | |
| uint32_t flags; | |
| } __attribute__((packed)) LpMetadataBlockDevice; | |
| /* This flag is only intended to be used with super_empty.img and super.img on | |
| * retrofit devices. On these devices there are A and B super partitions, and | |
| * we don't know ahead of time which slot the image will be applied to. | |
| * | |
| * If set, the block device needs a slot suffix applied before being used with | |
| * IPartitionOpener. The slot suffix is determined by the metadata slot number | |
| * (0 = _a, 1 = _b). | |
| */ | |
| #define LP_BLOCK_DEVICE_SLOT_SUFFIXED (1 << 0) | |
| typedef struct PartitionList | |
| { | |
| char name[128]; | |
| struct PartitionList* next; | |
| }__attribute__((packed)) PartitionList; | |
| PartitionList* part_list = NULL; | |
| void printlist(void) | |
| { | |
| PartitionList* node = part_list; | |
| while (NULL != node) | |
| { | |
| printf("name: %s\n",node->name); | |
| node = node->next; | |
| } | |
| } | |
| int GetPrimaryGeometryOffset(void) { | |
| int offset = LP_PARTITION_RESERVED_BYTES; | |
| return offset; | |
| } | |
| int GetBackupGeometryOffset(void) { | |
| int offset = GetPrimaryGeometryOffset() + LP_METADATA_GEOMETRY_SIZE; | |
| return offset; | |
| } | |
| int GetPrimaryMetadataOffset(LpMetadataGeometry* geometry, int slot_number) { | |
| int offset = LP_PARTITION_RESERVED_BYTES + (LP_METADATA_GEOMETRY_SIZE * 2) + | |
| geometry->metadata_max_size * slot_number; | |
| printf("GetPrimaryMetadataOffset : %d\n", offset); | |
| return offset; | |
| } | |
| int GetBackupMetadataOffset(LpMetadataGeometry* geometry, int slot_number) { | |
| int start = LP_PARTITION_RESERVED_BYTES + (LP_METADATA_GEOMETRY_SIZE * 2) + | |
| geometry->metadata_max_size * geometry->metadata_slot_count; | |
| printf("GetBackupMetadataOffset : %d\n", start + geometry->metadata_max_size * slot_number); | |
| return start + geometry->metadata_max_size * slot_number; | |
| } | |
| int GetTotalMetadataSize(int metadata_max_size, int max_slots) { | |
| return LP_PARTITION_RESERVED_BYTES + | |
| (LP_METADATA_GEOMETRY_SIZE + metadata_max_size * max_slots) * 2; | |
| } | |
| int ParseGeometry(const void* buffer, LpMetadataGeometry* geometry) { | |
| memcpy(geometry, buffer, sizeof(LpMetadataGeometry)); | |
| // Check the magic signature. | |
| if (geometry->magic != LP_METADATA_GEOMETRY_MAGIC) { | |
| printf("Logical partition metadata has invalid geometry magic signature\n"); | |
| return -1; | |
| } | |
| // Reject if the struct size is larger than what we compiled. This is so we | |
| // can compute a checksum with the |struct_size| field rather than using | |
| // sizeof. | |
| if (geometry->struct_size > sizeof(LpMetadataGeometry)) { | |
| printf("Logical partition metadata has unrecognized fields.\n"); | |
| return -1; | |
| } | |
| // Check that the struct size is equal (this will have to change if we ever | |
| // change the struct size in a release). | |
| if (geometry->struct_size != sizeof(LpMetadataGeometry)) { | |
| printf("Logical partition metadata has invalid struct size.\n"); | |
| return -1; | |
| } | |
| if (geometry->metadata_slot_count == 0) { | |
| printf("Logical partition metadata has invalid slot count.\n"); | |
| return -1; | |
| } | |
| if (geometry->metadata_max_size % LP_SECTOR_SIZE != 0) { | |
| printf("Metadata max size is not sector-aligned.\n"); | |
| return -1; | |
| } | |
| return 0; | |
| } | |
| int ReadPrimaryGeometry(char *superbuf, LpMetadataGeometry* geometry) { | |
| char buffer[LP_METADATA_GEOMETRY_SIZE]; | |
| memcpy(buffer, superbuf+LP_PARTITION_RESERVED_BYTES, LP_METADATA_GEOMETRY_SIZE); | |
| return ParseGeometry(buffer, geometry); | |
| } | |
| int ReadBackupGeometry(char *superbuf, LpMetadataGeometry* geometry) { | |
| char buffer[LP_METADATA_GEOMETRY_SIZE]; | |
| memcpy(buffer, superbuf+LP_PARTITION_RESERVED_BYTES+LP_METADATA_GEOMETRY_SIZE, LP_METADATA_GEOMETRY_SIZE); | |
| return ParseGeometry(buffer, geometry); | |
| } | |
| // Read and validate geometry information from a block device that holds | |
| // logical partitions. If the information is corrupted, this will attempt | |
| // to read it from a secondary backup location. | |
| int ReadLogicalPartitionGeometry(char *superbuf, LpMetadataGeometry* geometry) { | |
| if (ReadPrimaryGeometry(superbuf, geometry) == 0) { | |
| return 0; | |
| } | |
| return ReadBackupGeometry(superbuf, geometry); | |
| } | |
| static int ValidateMetadataHeader(LpMetadataHeader* header) { | |
| // Do basic validation of key metadata bits. | |
| if (header->magic != LP_METADATA_HEADER_MAGIC) { | |
| printf("Logical partition metadata has invalid magic value.\n"); | |
| return -1; | |
| } | |
| // Check that the version is compatible. | |
| if (header->major_version != LP_METADATA_MAJOR_VERSION || | |
| header->minor_version > LP_METADATA_MINOR_VERSION) { | |
| printf("Logical partition metadata has incompatible version.\n"); | |
| return -1; | |
| } | |
| /*if (!ValidateTableBounds(header, &header->partitions) || | |
| !ValidateTableBounds(header, &header->extents) || | |
| !ValidateTableBounds(header, &header->groups) || | |
| !ValidateTableBounds(header, &header->block_devices)) { | |
| printf("Logical partition metadata has invalid table bounds.\n"); | |
| return -1; | |
| }*/ | |
| // Check that table entry sizes can accomodate their respective structs. If | |
| // table sizes change, these checks will have to be adjusted. | |
| if (header->partitions.entry_size != sizeof(LpMetadataPartition)) { | |
| printf("Logical partition metadata has invalid partition table entry size.\n"); | |
| return -1; | |
| } | |
| if (header->extents.entry_size != sizeof(LpMetadataExtent)) { | |
| printf("Logical partition metadata has invalid extent table entry size.\n"); | |
| return -1; | |
| } | |
| if (header->groups.entry_size != sizeof(LpMetadataPartitionGroup)) { | |
| printf("Logical partition metadata has invalid group table entry size.\n"); | |
| return -1; | |
| } | |
| return 0; | |
| } | |
| int ReadMetadataHeader(char *superbuf, LpMetadataHeader* header, | |
| LpMetadataGeometry* geometry, int slot_number) { | |
| char* buffer = NULL; | |
| int cursor = 0; | |
| PartitionList* tail = NULL ; | |
| PartitionList* node = NULL ; | |
| int ishead = 0; | |
| int i; | |
| printf("metaoffset: %d\n", GetPrimaryMetadataOffset(geometry, slot_number)); | |
| memcpy(header, superbuf + GetPrimaryMetadataOffset(geometry, slot_number), sizeof(LpMetadataHeader)); | |
| if (ValidateMetadataHeader(header) != 0) { | |
| return -1; | |
| } | |
| printf("header table size = %d\n", header->tables_size); | |
| buffer = (char*)malloc(header->tables_size); | |
| if (buffer == NULL) { | |
| printf("Out of memory reading logical partition tables.\n"); | |
| return -1; | |
| } | |
| memcpy(buffer, superbuf + GetPrimaryMetadataOffset(geometry, slot_number) + sizeof(LpMetadataHeader), header->tables_size); | |
| cursor = GetPrimaryMetadataOffset(geometry, slot_number) + sizeof(LpMetadataHeader) + header->partitions.offset; | |
| printf("header->partitions.offset: %d\n", header->partitions.offset); | |
| printf("cursor: %d\n", cursor); | |
| // ValidateTableSize ensured that |cursor| is valid for the number of | |
| // entries in the table. | |
| for (i = 0; i < header->partitions.num_entries; i++) { | |
| LpMetadataPartition partition; | |
| memcpy(&partition, superbuf + cursor, sizeof(partition)); | |
| cursor += header->partitions.entry_size; | |
| printf("partition name : %s\n", partition.name); | |
| if (partition.attributes & ~LP_PARTITION_ATTRIBUTE_MASK) { | |
| printf("Logical partition has invalid attribute set.\n"); | |
| if (buffer) | |
| free (buffer); | |
| return -1; | |
| } | |
| if (partition.first_extent_index + partition.num_extents < partition.first_extent_index) { | |
| printf("Logical partition first_extent_index + num_extents overflowed.\n"); | |
| if (buffer) | |
| free (buffer); | |
| return -1; | |
| } | |
| if (partition.first_extent_index + partition.num_extents > header->extents.num_entries) { | |
| printf("Logical partition has invalid extent list.\n"); | |
| if (buffer) | |
| free (buffer); | |
| return -1; | |
| } | |
| if (partition.group_index >= header->groups.num_entries) { | |
| printf("Logical partition has invalid group index.\n"); | |
| if (buffer) | |
| free (buffer); | |
| return -1; | |
| } | |
| node = malloc(sizeof(PartitionList)); | |
| strcpy(node->name, partition.name); | |
| if (ishead == 0) | |
| { | |
| part_list = node ; | |
| part_list->next = NULL ; | |
| tail = node; | |
| ishead = -1; | |
| } | |
| else | |
| { | |
| tail->next = node; | |
| tail = node; | |
| } | |
| //metadata->partitions.push_back(partition); | |
| } | |
| if (NULL != tail) | |
| tail->next = NULL; | |
| if (buffer) | |
| free (buffer); | |
| return 0; | |
| } | |
| /*void dump_mem(char * buffer, int count) | |
| { | |
| int i; | |
| printf("***********************************************\n"); | |
| for (i=0; i<count ; i++) | |
| { | |
| if (i % 16 == 0) | |
| printf("\n"); | |
| printf("%02x ", buffer[i]); | |
| } | |
| printf("\n"); | |
| printf("***********************************************\n"); | |
| }*/ | |
| int do_ReadMetadata(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) | |
| { | |
| char *partition = "super"; | |
| char* superbuf; | |
| LpMetadataGeometry geometry; | |
| LpMetadataHeader metadata_header; | |
| char *slot; | |
| int slot_number = 0; | |
| superbuf = (char*)malloc(SUPERBUF_SIZE); | |
| if (superbuf == NULL) { | |
| printf("Out of memory reading logical partition tables.\n"); | |
| goto ERR; | |
| } | |
| if (dynamic_partition) { | |
| if (store_read_ops((unsigned char *)partition, | |
| (unsigned char *)superbuf, 0, SUPERBUF_SIZE) < 0) { | |
| printf("failed to store read %s.\n", partition); | |
| goto ERR; | |
| } | |
| //dump_mem(superbuf, SUPERBUF_SIZE); | |
| if (ReadLogicalPartitionGeometry(superbuf, &geometry) != 0) { | |
| goto ERR; | |
| } | |
| if (has_boot_slot == 1) { | |
| slot = getenv("slot-suffixes"); | |
| printf("slot-suffixes: %s\n", slot); | |
| if (strcmp(slot, "0") == 0) { | |
| slot_number = 0; | |
| } else if (strcmp(slot, "1") == 0) { | |
| slot_number = 1; | |
| } | |
| } | |
| ReadMetadataHeader(superbuf, &metadata_header, &geometry, slot_number); | |
| //printlist(); | |
| } | |
| if (superbuf) | |
| free (superbuf); | |
| return 0; | |
| ERR: | |
| if (superbuf) | |
| free (superbuf); | |
| return -1; | |
| } | |
| int is_partition_logical(const char *parition_name) | |
| { | |
| run_command("readMetadata", 0); | |
| PartitionList* node = part_list; | |
| while (NULL != node) | |
| { | |
| printf("name: %s\n",node->name); | |
| if (strcmp(node->name, parition_name) == 0) | |
| return 0; | |
| node = node->next; | |
| } | |
| return -1; | |
| } | |
| #else | |
| static int do_ReadMetadata( | |
| cmd_tbl_t * cmdtp, | |
| int flag, | |
| int argc, | |
| char * const argv[]) { | |
| // Do-Nothing! | |
| return 0; | |
| } | |
| #endif /* CONFIG_BOOTLOADER_CONTROL_BLOCK */ | |
| U_BOOT_CMD( | |
| readMetadata, 1, 0, do_ReadMetadata, | |
| "readMetadata", | |
| "\nThis command will read metadata in super \n" | |
| "So you can execute command: readMetadata" | |
| ); | |