Skip to contentSkip to conversation

Introduce NVIDIA Tegra Partition Table

PATCH In review Dmitry Osipenko 2 participants 11 messages May 17, 2020 – May 18, 2020

Subsystems (7)
lore
Share & tools
lore
#0 lore raw

v6 cover Introduce NVIDIA Tegra Partition Table

Hello,

This series adds support for the NVIDIA Tegra Partition Table format, which is needed in order to support consumer-grade Tegra-based devices by the upstream kernel. These devices have Secure Boot enabled and it can't be disabled, and thus, it's not possible to easily modify bootloader and eMMC storage partitioning.

Big thanks to everyone who helped with figuring out the TegraPT format and with testing!

Changelog:

v6: - Now using a proper multi-line comments style in efi.c, thanks to
Randy Dunlap for the suggestion.

- Added new patch that improves coding style of partitions/efi.c

- Now both "gpt gpt_sector=<sector>" and "gpt_sector=<sector> gpt" cmdline variants are parsed properly. I found that the second variant wasn't working in v5.

- Fixed accidentally swapped GFP_KERNEL flag and allocation size passed to kmalloc() in the patch "Expose Boot Configuration Table via sysfs". Thanks to KASAN for reporting the problem.

v5: - Corrected Kconfig dependency, like it was suggested by Randy Dunlap
in the review comment to v4.

- Corrected a typo in the commit message, which was spotted by Steve McIntyre in v4.

- The new force_gpt_sector variable has been moved out to the common parser state because I realized that multiple drives could be scanned simultaneously, and thus, a global shared variable isn't a suitable variant.

- The Tegra's enforced GPT-scan now supports older bootloader versions, which do not provide the gpt_sector= command line option. The gpt_sector should be calculated using NVIDIA's algorithm in this case.

v4: - Scanning of the eMMC boot partitions has been dropped because it
requires a bit too messy hacks in the kernel. We can live without this feature, at least for now it's not really needed.

- Instead of the dropped boot partitions scanning, the "gpt_sector=" command line option has been brought back [1]. But now it's done in a different way, not bothering platforms other than Tegra and not touching block devices other than eMMC, which was requested during of the [1] review. The "gpt_sector=" usage is needed when partition table is inaccessible by kernel, which is the case for the Ouya game console device for example. Please note that "gpt_sector=" is not available on all devices, such devices will fall back to the TegraPT, Samsung Galaxy Tab 10.1 is an example of a such device.

[1] https://patchwork.ozlabs.org/project/linux-tegra/patch/[email protected]/

- We got a bit more broad testing and discovered that Samsung Galaxy Tab 10.1 uses 2K logical sectors instead of 4K. So the 2K sectors are supported now by the TegraPT parser. Thanks to Nils Östlund for the testing!

- TegraPT parser now utilizes "tegraboot=" cmdline option which is passed to kernel by the NVIDIA's bootloader. It's used for verifying that SDMMC device is *the* boot source.

- Added patch that exposes Boot Configuration Table to userspace via sysfs. Thanks to Michał Mirosław for the suggestion!

- Misc changes:
- The EB2 (second bootloader) partition is added to the list of known partitions. Used by the Galaxy Tab 10.

- The blkdev logical sector size is checked now, for consistency. It always should be 512 bytes on the supported/tested devices.

- Verbose error messages are replaced with pr_debug().

v3: - Fixed "BUG: KASAN: slab-out-of-bounds in tegra_partition". Thanks to
Peter Geis for noticing the problem.

- The MMC boot partitions scanning is now opt-in. See this patch:

mmc: block: Support partition-table scanning on boot partitions

- The found MMC boot partitions won't be assigned to the MMC boot block device ever due to the new GENHD_FL_PART_SCAN_ONCE flag.

This makes us to ensure that the old behavior of the MMC core is preserved for a non-Tegra MMC-block users.

New patches in v3:

block: Introduce GENHD_FL_PART_SCAN_ONCE
mmc: sdhci-tegra: Enable boot partitions scanning on Tegra20 and Tegra30

v2: - Addressed v1 review comments from Stephen Warren by using BIT for
locating BCT position in IRAM.

- Added more validations to the TegraPT parser: partition type is verified, eMMC instance ID is verified.

- TegraPT parser now doesn't touch any devices other than eMMC.

- EKS (encrypted keys) partition is blacklisted now.

- Implemented eMMC boot partitions scanning. These new patches are added in a result:

mmc: block: Add mmc_bdev_to_part_type() helper
mmc: block: Add mmc_bdev_to_area_type() helper
mmc: block: Add MMC_QUIRK_RESCAN_MAIN_BLKDEV
mmc: block: Enable partition-table scanning for boot partitions partitions/tegra: Implement eMMC boot partitions scanning

Dmitry Osipenko (7):
mmc: core: Add raw_boot_mult field to mmc_ext_csd
mmc: block: Add mmc_bdev_to_card() helper
partitions: Introduce NVIDIA Tegra Partition Table partitions/efi: Support GPT entry lookup at a non-standard location partitions/efi: Improve coding style
partitions/tegra: Support enforced GPT scanning soc/tegra: Expose Boot Configuration Table via sysfs

 arch/arm/mach-tegra/tegra.c   |  58 ++++
 block/partitions/Kconfig      |   8 +
 block/partitions/Makefile     |   1 +
 block/partitions/check.h      |   3 +
 block/partitions/core.c       |   4 +
 block/partitions/efi.c        | 372 ++++++++++----------
 block/partitions/tegra.c      | 624 ++++++++++++++++++++++++++++++++++
 drivers/mmc/core/block.c      |  15 +
 drivers/mmc/core/mmc.c        |   2 +
 drivers/soc/tegra/Makefile    |   1 +
 drivers/soc/tegra/bootdata.c  |  51 +++
 drivers/soc/tegra/common.c    |  17 +
 include/linux/mmc/blkdev.h    |  13 +
 include/linux/mmc/card.h      |   1 +
 include/soc/tegra/bootdata.h  |  48 +++
 include/soc/tegra/common.h    |  12 +
 include/soc/tegra/partition.h |  84 +++++
 17 files changed, 1135 insertions(+), 179 deletions(-)
 create mode 100644 block/partitions/tegra.c
 create mode 100644 drivers/soc/tegra/bootdata.c
 create mode 100644 include/linux/mmc/blkdev.h
 create mode 100644 include/soc/tegra/bootdata.h
 create mode 100644 include/soc/tegra/partition.h
Signature · 1 line
2.26.0
#1 lore raw

PATCH v6 1/7 mmc: core: Add raw_boot_mult field to mmc_ext_csd

In order to support parsing of NVIDIA Tegra Partition Table format, we need to know the BOOT_SIZE_MULT value of the Extended CSD register because NVIDIA's bootloader linearizes the boot0/boot1/main partitions into a single virtual space, and thus, all partition addresses are shifted by the size of boot0 + boot1 partitions.

---
 drivers/mmc/core/mmc.c   | 2 ++
 include/linux/mmc/card.h | 1 +
 2 files changed, 3 insertions(+)
drivers/mmc/core/mmc.c +2 -0
index 4203303f946a..112edfb1eb1d 100644
@@ -417,6 +417,8 @@ static int mmc_decode_ext_csd(struct mmc_card *card, u8 *ext_csd)
 		ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT];
 	card->ext_csd.raw_hc_erase_grp_size =
 		ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
+	card->ext_csd.raw_boot_mult =
+		ext_csd[EXT_CSD_BOOT_MULT];
 	if (card->ext_csd.rev >= 3) {
 		u8 sa_shift = ext_csd[EXT_CSD_S_A_TIMEOUT];
 		card->ext_csd.part_config = ext_csd[EXT_CSD_PART_CONFIG];
include/linux/mmc/card.h +1 -0
index 7d46411ffaa2..cd6b58b66010 100644
@@ -109,6 +109,7 @@ struct mmc_ext_csd {
 	u8			raw_hc_erase_gap_size;	/* 221 */
 	u8			raw_erase_timeout_mult;	/* 223 */
 	u8			raw_hc_erase_grp_size;	/* 224 */
+	u8			raw_boot_mult;		/* 226 */
 	u8			raw_sec_trim_mult;	/* 229 */
 	u8			raw_sec_erase_mult;	/* 230 */
 	u8			raw_sec_feature_support;/* 231 */
Signature · 1 line
2.26.0
#2 lore raw

PATCH v6 2/7 mmc: block: Add mmc_bdev_to_card() helper

In reply to Dmitry Osipenko

NVIDIA Tegra Partition Table takes into account MMC card's BOOT_SIZE_MULT parameter, and thus, the partition parser needs to retrieve that EXT_CSD value from the block device. There are also some other parts of struct mmc_card that are needed for the partition parser in order to calculate the eMMC offset and verify different things. This patch introduces new helper which takes block device for the input argument and returns the corresponding MMC card.

---
 drivers/mmc/core/block.c   | 15 +++++++++++++++
 include/linux/mmc/blkdev.h | 13 +++++++++++++
 2 files changed, 28 insertions(+)
 create mode 100644 include/linux/mmc/blkdev.h
drivers/mmc/core/block.c +15 -0
index c5367e2c8487..99298e888381 100644
@@ -40,6 +40,7 @@
 #include <linux/debugfs.h>
 
 #include <linux/mmc/ioctl.h>
+#include <linux/mmc/blkdev.h>
 #include <linux/mmc/card.h>
 #include <linux/mmc/host.h>
 #include <linux/mmc/mmc.h>
@@ -305,6 +306,20 @@ static ssize_t force_ro_store(struct device *dev, struct device_attribute *attr,
 	return ret;
 }
 
+struct mmc_card *mmc_bdev_to_card(struct block_device *bdev)
+{
+	struct mmc_blk_data *md;
+
+	if (bdev->bd_disk->major != MMC_BLOCK_MAJOR)
+		return NULL;
+
+	md = mmc_blk_get(bdev->bd_disk);
+	if (!md)
+		return NULL;
+
+	return md->queue.card;
+}
+
 static int mmc_blk_open(struct block_device *bdev, fmode_t mode)
 {
 	struct mmc_blk_data *md = mmc_blk_get(bdev->bd_disk);
include/linux/mmc/blkdev.h new file +13 -0
new file mode 100644
index 000000000000..67608c58de70
@@ -0,0 +1,13 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ *  linux/include/linux/mmc/blkdev.h
+ */
+#ifndef LINUX_MMC_BLOCK_DEVICE_H
+#define LINUX_MMC_BLOCK_DEVICE_H
+
+struct block_device;
+struct mmc_card;
+
+struct mmc_card *mmc_bdev_to_card(struct block_device *bdev);
+
+#endif /* LINUX_MMC_BLOCK_DEVICE_H */
Signature · 1 line
2.26.0
#6 lore raw

PATCH v6 3/7 partitions: Introduce NVIDIA Tegra Partition Table

In reply to Dmitry Osipenko

All NVIDIA Tegra devices use a special partition table format for the internal storage partitioning. Most of Tegra devices have GPT partition in addition to TegraPT, but some older Android consumer-grade devices do not or GPT is placed in a wrong sector, and thus, the TegraPT is needed in order to support these devices properly by the upstream kernel. This patch adds support for NVIDIA Tegra Partition Table format that is used at least by all NVIDIA Tegra20 and Tegra30 devices.

---
 arch/arm/mach-tegra/tegra.c   |  54 ++++
 block/partitions/Kconfig      |   8 +
 block/partitions/Makefile     |   1 +
 block/partitions/check.h      |   1 +
 block/partitions/core.c       |   3 +
 block/partitions/tegra.c      | 567 ++++++++++++++++++++++++++++++++++
 include/soc/tegra/bootdata.h  |  46 +++
 include/soc/tegra/common.h    |   9 +
 include/soc/tegra/partition.h |  84 +++++
 9 files changed, 773 insertions(+)
 create mode 100644 block/partitions/tegra.c
 create mode 100644 include/soc/tegra/bootdata.h
 create mode 100644 include/soc/tegra/partition.h
arch/arm/mach-tegra/tegra.c +54 -0
index c011359bcdb4..da6bcd85398b 100644
@@ -28,7 +28,9 @@
 
 #include <linux/firmware/trusted_foundations.h>
 
+#include <soc/tegra/bootdata.h>
 #include <soc/tegra/fuse.h>
+#include <soc/tegra/partition.h>
 #include <soc/tegra/pmc.h>
 
 #include <asm/firmware.h>
@@ -62,9 +64,61 @@ u32 tegra_uart_config[3] = {
 	0,
 };
 
+static void __init tegra_boot_config_table_init(void)
+{
+	struct tegra30_boot_config_table __iomem *t30_bct;
+	struct tegra20_boot_config_table __iomem *t20_bct;
+	struct tegra20_boot_info_table   __iomem *t20_bit;
+	u32 iram_end   = TEGRA_IRAM_BASE + TEGRA_IRAM_SIZE;
+	u32 iram_start = TEGRA_IRAM_BASE;
+	u32 pt_addr, pt_size, bct_size;
+
+	t20_bit = IO_ADDRESS(TEGRA_IRAM_BASE);
+
+	if (of_machine_is_compatible("nvidia,tegra20")) {
+		bct_size = sizeof(*t20_bct);
+
+		if (t20_bit->bct_size != bct_size ||
+		    t20_bit->bct_ptr < iram_start ||
+		    t20_bit->bct_ptr > iram_end - bct_size)
+			return;
+
+		t20_bct = IO_ADDRESS(t20_bit->bct_ptr);
+
+		if (t20_bct->boot_data_version != TEGRA_BOOTDATA_VERSION_T20)
+			return;
+
+		pt_addr = t20_bct->partition_table_logical_sector_address;
+		pt_size = t20_bct->partition_table_num_logical_sectors;
+
+	} else if (of_machine_is_compatible("nvidia,tegra30")) {
+		bct_size = sizeof(*t30_bct);
+
+		if (t20_bit->bct_size != bct_size ||
+		    t20_bit->bct_ptr < iram_start ||
+		    t20_bit->bct_ptr > iram_end - bct_size)
+			return;
+
+		t30_bct = IO_ADDRESS(t20_bit->bct_ptr);
+
+		if (t30_bct->boot_data_version != TEGRA_BOOTDATA_VERSION_T30)
+			return;
+
+		pt_addr = t30_bct->partition_table_logical_sector_address;
+		pt_size = t30_bct->partition_table_num_logical_sectors;
+	} else {
+		return;
+	}
+
+	pr_info("%s: BCT found in IRAM\n", __func__);
+
+	tegra_partition_table_setup(pt_addr, pt_size);
+}
+
 static void __init tegra_init_early(void)
 {
 	of_register_trusted_foundations();
+	tegra_boot_config_table_init();
 	tegra_cpu_reset_handler_init();
 	call_firmware_op(l2x0_init);
 }
block/partitions/Kconfig +8 -0
index 702689a628f0..97cd4a030f98 100644
@@ -268,3 +268,11 @@ config CMDLINE_PARTITION
 	help
 	  Say Y here if you want to read the partition table from bootargs.
 	  The format for the command line is just like mtdparts.
+
+config TEGRA_PARTITION
+	bool "NVIDIA Tegra Partition support" if PARTITION_ADVANCED
+	default y if ARCH_TEGRA
+	depends on MMC_BLOCK && (ARCH_TEGRA || COMPILE_TEST)
+	help
+	  Say Y here if you would like to be able to read the hard disk
+	  partition table format used by NVIDIA Tegra machines.
block/partitions/Makefile +1 -0
index a7f05cdb02a8..83cb70c6d08d 100644
@@ -20,3 +20,4 @@ obj-$(CONFIG_IBM_PARTITION) += ibm.o
 obj-$(CONFIG_EFI_PARTITION) += efi.o
 obj-$(CONFIG_KARMA_PARTITION) += karma.o
 obj-$(CONFIG_SYSV68_PARTITION) += sysv68.o
+obj-$(CONFIG_TEGRA_PARTITION) += tegra.o
block/partitions/check.h +1 -0
index c577e9ee67f0..ffa01cc4b0b0 100644
@@ -67,4 +67,5 @@ int osf_partition(struct parsed_partitions *state);
 int sgi_partition(struct parsed_partitions *state);
 int sun_partition(struct parsed_partitions *state);
 int sysv68_partition(struct parsed_partitions *state);
+int tegra_partition(struct parsed_partitions *state);
 int ultrix_partition(struct parsed_partitions *state);
block/partitions/core.c +3 -0
index 297004fd2264..0b4720372f07 100644
@@ -81,6 +81,9 @@ static int (*check_part[])(struct parsed_partitions *) = {
 #endif
 #ifdef CONFIG_SYSV68_PARTITION
 	sysv68_partition,
+#endif
+#ifdef CONFIG_TEGRA_PARTITION
+	tegra_partition,
 #endif
 	NULL
 };
block/partitions/tegra.c new file +567 -0

567 lines not on this page · raw message

include/soc/tegra/bootdata.h new file +46 -0

46 lines not on this page · raw message

include/soc/tegra/common.h +9 -0
index 98027a76ce3d..744280ecab5f 100644
@@ -6,6 +6,15 @@
 #ifndef __SOC_TEGRA_COMMON_H__
 #define __SOC_TEGRA_COMMON_H__
 
+#include <linux/types.h>
+
+#ifdef CONFIG_ARCH_TEGRA
 bool soc_is_tegra(void);
+#else
+static inline bool soc_is_tegra(void)
+{
+	return false;
+}
+#endif
 
 #endif /* __SOC_TEGRA_COMMON_H__ */
include/soc/tegra/partition.h new file +84 -0

84 lines not on this page · raw message

Signature · 1 line
2.26.0
#7 lore raw

PATCH v6 4/7 partitions/efi: Support GPT entry lookup at a non-standard location

In reply to Dmitry Osipenko

Most of consumer-grade NVIDIA Tegra devices use a proprietary bootloader that can't be easily replaced because it's locked down using Secure Boot cryptography signing and the crypto keys aren't given to a device owner. These devices usually have eMMC storage that is partitioned using a custom NVIDIA Tegra partition table format. Of course bootloader and other "special things" are stored on the eMMC storage, and thus, the partition format can't be changed.

The Tegra partition format has been reverse-engineered, but NVIDIA uses a virtually merged "boot" and "main" eMMC HW partitions in theirs bootloader. This is not supported by Linux kernel and can't be easily implemented. Hence partition table entry isn't accessible by kernel if it's located at the "boot" eMMC partition. Luckily this is a rare case in practice and even if it's the case, likely that the proprietary bootloader will supply kernel with a non-standard gpt_sector= cmdline option. This gpt_sector= argument points at a GPT entry which resides at a non-standard location on the eMMC storage.

This patch allows to support the non-standard cmdline option for NVIDIA Tegra devices without bothering any other platforms. The force_gpt_sector parser-state struct member should be set before invoking efi_partition() and it should be unset after the invocation completion. This new parser member instructs GPT parser to look up GPT entry at the given sector if state->force_gpt_sector != 0.

This patch is based on the original work done by Colin Cross for the downstream Android kernel.

---
 block/partitions/check.h | 1 +
 block/partitions/efi.c   | 9 +++++++++
 2 files changed, 10 insertions(+)
block/partitions/check.h +1 -0
index ffa01cc4b0b0..55acf6340e5b 100644
@@ -22,6 +22,7 @@ struct parsed_partitions {
 	int limit;
 	bool access_beyond_eod;
 	char *pp_buf;
+	sector_t force_gpt_sector;
 };
 
 typedef struct {
block/partitions/efi.c +9 -0
index b64bfdd4326c..34c25f708733 100644
@@ -621,6 +621,15 @@ static int find_valid_gpt(struct parsed_partitions *state, gpt_header **gpt,
         if (!good_agpt && force_gpt)
                 good_agpt = is_gpt_valid(state, lastlba, &agpt, &aptes);
 
+	/*
+	 * The force_gpt_sector is used by NVIDIA Tegra partition parser in
+	 * order to convey a non-standard location of the GPT entry for lookup.
+	 * By default force_gpt_sector is set to 0 and has no effect.
+	 */
+	if (!good_agpt && force_gpt && state->force_gpt_sector)
+		good_agpt = is_gpt_valid(state, state->force_gpt_sector,
+					 &agpt, &aptes);
+
         /* The obviously unsuccessful case */
         if (!good_pgpt && !good_agpt)
                 goto fail;
Signature · 1 line
2.26.0
#8 lore raw

PATCH v6 5/7 partitions/efi: Improve coding style

In reply to Dmitry Osipenko

The 'efi.c' source code has a lot of coding style problems like:

- trailing whitespaces
- whitespaces instead of tabs
- missing whitespaces where they actually needed
- double blank-lines
- improperly aligned code
- improperly styled multi-line comments
- unnecessarily assigned variables
- NULL-checks that can't ever trigger

and etc.

This patch fixes few dozen of coding style problems without introducing any functional changes, making code easier to read, and thus, easier to maintain.

---
 block/partitions/efi.c | 354 ++++++++++++++++++++---------------------
 1 file changed, 175 insertions(+), 179 deletions(-)
block/partitions/efi.c +175 -179
index 34c25f708733..f0229e7a6894 100644
@@ -23,7 +23,7 @@
  * - Ported to 2.5.7-pre1 and 2.5.7-dj2
  * - Applied patch to avoid fault in alternate header handling
  * - cleaned up find_valid_gpt
- * - On-disk structure and copy in memory is *always* LE now - 
+ * - On-disk structure and copy in memory is *always* LE now -
  *   swab fields as needed
  * - remove print_gpt_header()
  * - only use first max_p partition entries, to keep the kernel minor number
@@ -40,7 +40,7 @@
  * - moved le_efi_guid_to_cpus() back into this file.  GPT is the only
  *   thing that keeps EFI GUIDs on disk.
  * - Changed gpt structure names and members to be simpler and more Linux-like.
- * 
+ *
  * Wed Oct 17 2001 Matt Domsch <[email protected]>
  * - Removed CONFIG_DEVFS_VOLUMES_UUID code entirely per Martin Wilck
  *
@@ -65,7 +65,7 @@
  *
  * Wed Jun  6 2001 Martin Wilck <[email protected]>
  * - added devfs volume UUID support (/dev/volumes/uuids) for
- *   mounting file systems by the partition GUID. 
+ *   mounting file systems by the partition GUID.
  *
  * Tue Dec  5 2000 Matt Domsch <[email protected]>
  * - Moved crc32() to linux/lib, added efi_crc32().
@@ -82,15 +82,18 @@
  * - Code works, detects all the partitions.
  *
  ************************************************************/
-#include <linux/kernel.h>
 #include <linux/crc32.h>
 #include <linux/ctype.h>
+#include <linux/kernel.h>
 #include <linux/math64.h>
 #include <linux/slab.h>
+#include <linux/types.h>
+
 #include "check.h"
 #include "efi.h"
 
-/* This allows a kernel command line option 'gpt' to override
+/*
+ * This allows a kernel command line option 'gpt' to override
  * the test for invalid PMBR.  Not __initdata because reloading
  * the partition tables happens after init too.
  */
@@ -103,14 +106,13 @@ force_gpt_fn(char *str)
 }
 __setup("gpt", force_gpt_fn);
 
-
 /**
  * efi_crc32() - EFI version of crc32 function
  * @buf: buffer to calculate crc32 of
  * @len: length of buf
  *
  * Description: Returns EFI-style CRC32 value for @buf
- * 
+ *
  * This function uses the little endian Ethernet polynomial
  * but seeds the function with ~0, and xor's with ~0 at the end.
  * Note, the EFI Specification, v1.02, has a reference to
@@ -125,7 +127,7 @@ efi_crc32(const void *buf, unsigned long len)
 /**
  * last_lba(): return number of last logical block of device
  * @bdev: block device
- * 
+ *
  * Description: Returns last LBA value on success, 0 on error.
  * This is stored (by sd and ide-geometry) in
  *  the part[0] entry for this disk, and is the number of
@@ -173,8 +175,8 @@ static inline int pmbr_part_valid(gpt_mbr_record *part)
  */
 static int is_pmbr_valid(legacy_mbr *mbr, sector_t total_sectors)
 {
-	uint32_t sz = 0;
-	int i, part = 0, ret = 0; /* invalid by default */
+	unsigned int i, sz = 0, part = 0;
+	int ret = 0; /* invalid by default */
 
 	if (!mbr || le16_to_cpu(mbr->signature) != MSDOS_MBR_SIGNATURE)
 		goto done;
@@ -195,11 +197,13 @@ static int is_pmbr_valid(legacy_mbr *mbr, sector_t total_sectors)
 	if (ret != GPT_MBR_PROTECTIVE)
 		goto done;
 check_hybrid:
-	for (i = 0; i < 4; i++)
-		if ((mbr->partition_record[i].os_type !=
-			EFI_PMBR_OSTYPE_EFI_GPT) &&
-		    (mbr->partition_record[i].os_type != 0x00))
+	for (i = 0; i < 4; i++) {
+		if (mbr->partition_record[i].os_type != EFI_PMBR_OSTYPE_EFI_GPT &&
+		    mbr->partition_record[i].os_type != 0x00) {
 			ret = GPT_MBR_HYBRID;
+			break;
+		}
+	}
 
 	/*
 	 * Protective MBRs take up the lesser of the whole disk
@@ -215,10 +219,9 @@ static int is_pmbr_valid(legacy_mbr *mbr, sector_t total_sectors)
 	 */
 	if (ret == GPT_MBR_PROTECTIVE) {
 		sz = le32_to_cpu(mbr->partition_record[part].size_in_lba);
-		if (sz != (uint32_t) total_sectors - 1 && sz != 0xFFFFFFFF)
-			pr_debug("GPT: mbr size in lba (%u) different than whole disk (%u).\n",
-				 sz, min_t(uint32_t,
-					   total_sectors - 1, 0xFFFFFFFF));
+		if (sz != (u32)total_sectors - 1 && sz != 0xFFFFFFFF)
+			pr_debug("GPT: mbr size in lba (%u) different than whole disk (%u)\n",
+				 sz, min_t(u32, total_sectors - 1, 0xFFFFFFFF));
 	}
 done:
 	return ret;
@@ -237,17 +240,18 @@ static int is_pmbr_valid(legacy_mbr *mbr, sector_t total_sectors)
 static size_t read_lba(struct parsed_partitions *state,
 		       u64 lba, u8 *buffer, size_t count)
 {
-	size_t totalreadcount = 0;
+	size_t totalreadcount = 0, copied;
 	struct block_device *bdev = state->bdev;
 	sector_t n = lba * (bdev_logical_block_size(bdev) / 512);
+	Sector sect;
+	u8 *data;
 
 	if (!buffer || lba > last_lba(bdev))
-                return 0;
+		return 0;
 
 	while (count) {
-		int copied = 512;
-		Sector sect;
-		unsigned char *data = read_part_sector(state, n++, &sect);
+		copied = 512;
+		data = read_part_sector(state, n++, &sect);
 		if (!data)
 			break;
 		if (copied > count)
@@ -255,7 +259,7 @@ static size_t read_lba(struct parsed_partitions *state,
 		memcpy(buffer, data, copied);
 		put_dev_sector(sect);
 		buffer += copied;
-		totalreadcount +=copied;
+		totalreadcount += copied;
 		count -= copied;
 	}
 	return totalreadcount;
@@ -265,7 +269,7 @@ static size_t read_lba(struct parsed_partitions *state,
  * alloc_read_gpt_entries(): reads partition entries from disk
  * @state: disk parsed partitions
  * @gpt: GPT header
- * 
+ *
  * Description: Returns ptes on success,  NULL on error.
  * Allocates space for PTEs based on information found in @gpt.
  * Notes: remember to free pte when you're done!
@@ -280,7 +284,7 @@ static gpt_entry *alloc_read_gpt_entries(struct parsed_partitions *state,
 		return NULL;
 
 	count = (size_t)le32_to_cpu(gpt->num_partition_entries) *
-                le32_to_cpu(gpt->sizeof_partition_entry);
+			le32_to_cpu(gpt->sizeof_partition_entry);
 	if (!count)
 		return NULL;
 	pte = kmalloc(count, GFP_KERNEL);
@@ -288,9 +292,8 @@ static gpt_entry *alloc_read_gpt_entries(struct parsed_partitions *state,
 		return NULL;
 
 	if (read_lba(state, le64_to_cpu(gpt->partition_entry_lba),
-			(u8 *) pte, count) < count) {
+		     (u8 *)pte, count) < count) {
 		kfree(pte);
-                pte=NULL;
 		return NULL;
 	}
 	return pte;
@@ -300,7 +303,7 @@ static gpt_entry *alloc_read_gpt_entries(struct parsed_partitions *state,
  * alloc_read_gpt_header(): Allocates GPT header, reads into it from disk
  * @state: disk parsed partitions
  * @lba: the Logical Block Address of the partition table
- * 
+ *
  * Description: returns GPT header on success, NULL on error.   Allocates
  * and fills a GPT header starting at @ from @state->bdev.
  * Note: remember to free gpt when finished with it.
@@ -308,16 +311,15 @@ static gpt_entry *alloc_read_gpt_entries(struct parsed_partitions *state,
 static gpt_header *alloc_read_gpt_header(struct parsed_partitions *state,
 					 u64 lba)
 {
+	unsigned int ssz = bdev_logical_block_size(state->bdev);
 	gpt_header *gpt;
-	unsigned ssz = bdev_logical_block_size(state->bdev);
 
 	gpt = kmalloc(ssz, GFP_KERNEL);
 	if (!gpt)
 		return NULL;
 
-	if (read_lba(state, lba, (u8 *) gpt, ssz) < ssz) {
+	if (read_lba(state, lba, (u8 *)gpt, ssz) < ssz) {
 		kfree(gpt);
-                gpt=NULL;
 		return NULL;
 	}
 
@@ -328,127 +330,130 @@ static gpt_header *alloc_read_gpt_header(struct parsed_partitions *state,
  * is_gpt_valid() - tests one GPT header and PTEs for validity
  * @state: disk parsed partitions
  * @lba: logical block address of the GPT header to test
- * @gpt: GPT header ptr, filled on return.
- * @ptes: PTEs ptr, filled on return.
+ * @ret_gpt: GPT header ptr, filled on successful return.
+ * @ret_ptes: PTEs ptr, filled on successful return.
  *
  * Description: returns 1 if valid,  0 on error.
  * If valid, returns pointers to newly allocated GPT header and PTEs.
  */
 static int is_gpt_valid(struct parsed_partitions *state, u64 lba,
-			gpt_header **gpt, gpt_entry **ptes)
+			gpt_header **ret_gpt, gpt_entry **ret_ptes)
 {
-	u32 crc, origcrc;
 	u64 lastlba, pt_size;
+	u32 crc, origcrc;
+	gpt_header *gpt;
+	gpt_entry *ptes;
 
-	if (!ptes)
-		return 0;
-	if (!(*gpt = alloc_read_gpt_header(state, lba)))
+	gpt = alloc_read_gpt_header(state, lba);
+	if (!gpt)
 		return 0;
 
 	/* Check the GUID Partition Table signature */
-	if (le64_to_cpu((*gpt)->signature) != GPT_HEADER_SIGNATURE) {
-		pr_debug("GUID Partition Table Header signature is wrong:"
-			 "%lld != %lld\n",
-			 (unsigned long long)le64_to_cpu((*gpt)->signature),
-			 (unsigned long long)GPT_HEADER_SIGNATURE);
+	if (le64_to_cpu(gpt->signature) != GPT_HEADER_SIGNATURE) {
+		pr_debug("GUID Partition Table Header signature is wrong: %lld != %lld\n",
+			 (u64)le64_to_cpu(gpt->signature),
+			 (u64)GPT_HEADER_SIGNATURE);
 		goto fail;
 	}
 
 	/* Check the GUID Partition Table header size is too big */
-	if (le32_to_cpu((*gpt)->header_size) >
+	if (le32_to_cpu(gpt->header_size) >
 			bdev_logical_block_size(state->bdev)) {
 		pr_debug("GUID Partition Table Header size is too large: %u > %u\n",
-			le32_to_cpu((*gpt)->header_size),
-			bdev_logical_block_size(state->bdev));
+			 le32_to_cpu(gpt->header_size),
+			 bdev_logical_block_size(state->bdev));
 		goto fail;
 	}
 
 	/* Check the GUID Partition Table header size is too small */
-	if (le32_to_cpu((*gpt)->header_size) < sizeof(gpt_header)) {
+	if (le32_to_cpu(gpt->header_size) < sizeof(gpt_header)) {
 		pr_debug("GUID Partition Table Header size is too small: %u < %zu\n",
-			le32_to_cpu((*gpt)->header_size),
-			sizeof(gpt_header));
+			 le32_to_cpu(gpt->header_size),
+			 sizeof(gpt_header));
 		goto fail;
 	}
 
 	/* Check the GUID Partition Table CRC */
-	origcrc = le32_to_cpu((*gpt)->header_crc32);
-	(*gpt)->header_crc32 = 0;
-	crc = efi_crc32((const unsigned char *) (*gpt), le32_to_cpu((*gpt)->header_size));
+	origcrc = le32_to_cpu(gpt->header_crc32);
+	gpt->header_crc32 = 0;
+	crc = efi_crc32(gpt, le32_to_cpu(gpt->header_size));
 
 	if (crc != origcrc) {
 		pr_debug("GUID Partition Table Header CRC is wrong: %x != %x\n",
 			 crc, origcrc);
 		goto fail;
 	}
-	(*gpt)->header_crc32 = cpu_to_le32(origcrc);
+	gpt->header_crc32 = cpu_to_le32(origcrc);
 
-	/* Check that the my_lba entry points to the LBA that contains
-	 * the GUID Partition Table */
-	if (le64_to_cpu((*gpt)->my_lba) != lba) {
+	/*
+	 * Check that the my_lba entry points to the LBA that contains
+	 * the GUID Partition Table.
+	 */
+	if (le64_to_cpu(gpt->my_lba) != lba) {
 		pr_debug("GPT my_lba incorrect: %lld != %lld\n",
-			 (unsigned long long)le64_to_cpu((*gpt)->my_lba),
-			 (unsigned long long)lba);
+			 (u64)le64_to_cpu(gpt->my_lba), lba);
 		goto fail;
 	}
 
-	/* Check the first_usable_lba and last_usable_lba are
+	/*
+	 * Check the first_usable_lba and last_usable_lba are
 	 * within the disk.
 	 */
 	lastlba = last_lba(state->bdev);
-	if (le64_to_cpu((*gpt)->first_usable_lba) > lastlba) {
+	if (le64_to_cpu(gpt->first_usable_lba) > lastlba) {
 		pr_debug("GPT: first_usable_lba incorrect: %lld > %lld\n",
-			 (unsigned long long)le64_to_cpu((*gpt)->first_usable_lba),
-			 (unsigned long long)lastlba);
+			 (u64)le64_to_cpu(gpt->first_usable_lba), lastlba);
 		goto fail;
 	}
-	if (le64_to_cpu((*gpt)->last_usable_lba) > lastlba) {
+	if (le64_to_cpu(gpt->last_usable_lba) > lastlba) {
 		pr_debug("GPT: last_usable_lba incorrect: %lld > %lld\n",
-			 (unsigned long long)le64_to_cpu((*gpt)->last_usable_lba),
-			 (unsigned long long)lastlba);
+			 (u64)le64_to_cpu(gpt->last_usable_lba), lastlba);
 		goto fail;
 	}
-	if (le64_to_cpu((*gpt)->last_usable_lba) < le64_to_cpu((*gpt)->first_usable_lba)) {
+	if (le64_to_cpu(gpt->last_usable_lba) <
+	    le64_to_cpu(gpt->first_usable_lba)) {
 		pr_debug("GPT: last_usable_lba incorrect: %lld > %lld\n",
-			 (unsigned long long)le64_to_cpu((*gpt)->last_usable_lba),
-			 (unsigned long long)le64_to_cpu((*gpt)->first_usable_lba));
+			 (u64)le64_to_cpu(gpt->last_usable_lba),
+			 (u64)le64_to_cpu(gpt->first_usable_lba));
 		goto fail;
 	}
 	/* Check that sizeof_partition_entry has the correct value */
-	if (le32_to_cpu((*gpt)->sizeof_partition_entry) != sizeof(gpt_entry)) {
-		pr_debug("GUID Partition Entry Size check failed.\n");
+	if (le32_to_cpu(gpt->sizeof_partition_entry) != sizeof(gpt_entry)) {
+		pr_debug("GUID Partition Entry Size check failed\n");
 		goto fail;
 	}
 
 	/* Sanity check partition table size */
-	pt_size = (u64)le32_to_cpu((*gpt)->num_partition_entries) *
-		le32_to_cpu((*gpt)->sizeof_partition_entry);
+	pt_size = (u64)le32_to_cpu(gpt->num_partition_entries) *
+		       le32_to_cpu(gpt->sizeof_partition_entry);
 	if (pt_size > KMALLOC_MAX_SIZE) {
 		pr_debug("GUID Partition Table is too large: %llu > %lu bytes\n",
-			 (unsigned long long)pt_size, KMALLOC_MAX_SIZE);
+			 pt_size, KMALLOC_MAX_SIZE);
 		goto fail;
 	}
 
-	if (!(*ptes = alloc_read_gpt_entries(state, *gpt)))
+	ptes = alloc_read_gpt_entries(state, gpt);
+	if (!ptes)
 		goto fail;
 
 	/* Check the GUID Partition Entry Array CRC */
-	crc = efi_crc32((const unsigned char *) (*ptes), pt_size);
+	crc = efi_crc32(ptes, pt_size);
 
-	if (crc != le32_to_cpu((*gpt)->partition_entry_array_crc32)) {
-		pr_debug("GUID Partition Entry Array CRC check failed.\n");
+	if (crc != le32_to_cpu(gpt->partition_entry_array_crc32)) {
+		pr_debug("GUID Partition Entry Array CRC check failed\n");
 		goto fail_ptes;
 	}
 
+	*ret_gpt  = gpt;
+	*ret_ptes = ptes;
+
 	/* We're done, all's well */
 	return 1;
 
- fail_ptes:
-	kfree(*ptes);
-	*ptes = NULL;
- fail:
-	kfree(*gpt);
-	*gpt = NULL;
+fail_ptes:
+	kfree(ptes);
+fail:
+	kfree(gpt);
 	return 0;
 }
 
@@ -462,8 +467,8 @@ static int is_gpt_valid(struct parsed_partitions *state, u64 lba,
 static inline int
 is_pte_valid(const gpt_entry *pte, const u64 lastlba)
 {
-	if ((!efi_guidcmp(pte->partition_type_guid, NULL_GUID)) ||
-	    le64_to_cpu(pte->starting_lba) > lastlba         ||
+	if ((!efi_guidcmp(pte->partition_type_guid, NULL_GUID))	||
+	    le64_to_cpu(pte->starting_lba) > lastlba		||
 	    le64_to_cpu(pte->ending_lba)   > lastlba)
 		return 0;
 	return 1;
@@ -477,98 +482,93 @@ is_pte_valid(const gpt_entry *pte, const u64 lastlba)
  *
  * Description: Returns nothing.  Sanity checks pgpt and agpt fields
  * and prints warnings on discrepancies.
- * 
+ *
  */
 static void
 compare_gpts(gpt_header *pgpt, gpt_header *agpt, u64 lastlba)
 {
-	int error_found = 0;
+	unsigned int error_found = 0;
+
 	if (!pgpt || !agpt)
 		return;
 	if (le64_to_cpu(pgpt->my_lba) != le64_to_cpu(agpt->alternate_lba)) {
 		pr_warn("GPT:Primary header LBA != Alt. header alternate_lba\n");
 		pr_warn("GPT:%lld != %lld\n",
-		       (unsigned long long)le64_to_cpu(pgpt->my_lba),
-                       (unsigned long long)le64_to_cpu(agpt->alternate_lba));
+			(u64)le64_to_cpu(pgpt->my_lba),
+			(u64)le64_to_cpu(agpt->alternate_lba));
 		error_found++;
 	}
 	if (le64_to_cpu(pgpt->alternate_lba) != le64_to_cpu(agpt->my_lba)) {
 		pr_warn("GPT:Primary header alternate_lba != Alt. header my_lba\n");
 		pr_warn("GPT:%lld != %lld\n",
-		       (unsigned long long)le64_to_cpu(pgpt->alternate_lba),
-                       (unsigned long long)le64_to_cpu(agpt->my_lba));
+			(u64)le64_to_cpu(pgpt->alternate_lba),
+			(u64)le64_to_cpu(agpt->my_lba));
 		error_found++;
 	}
 	if (le64_to_cpu(pgpt->first_usable_lba) !=
-            le64_to_cpu(agpt->first_usable_lba)) {
-		pr_warn("GPT:first_usable_lbas don't match.\n");
+	    le64_to_cpu(agpt->first_usable_lba)) {
+		pr_warn("GPT:first_usable_lbas don't match\n");
 		pr_warn("GPT:%lld != %lld\n",
-		       (unsigned long long)le64_to_cpu(pgpt->first_usable_lba),
-                       (unsigned long long)le64_to_cpu(agpt->first_usable_lba));
+			(u64)le64_to_cpu(pgpt->first_usable_lba),
+			(u64)le64_to_cpu(agpt->first_usable_lba));
 		error_found++;
 	}
 	if (le64_to_cpu(pgpt->last_usable_lba) !=
-            le64_to_cpu(agpt->last_usable_lba)) {
-		pr_warn("GPT:last_usable_lbas don't match.\n");
+	    le64_to_cpu(agpt->last_usable_lba)) {
+		pr_warn("GPT:last_usable_lbas don't match\n");
 		pr_warn("GPT:%lld != %lld\n",
-		       (unsigned long long)le64_to_cpu(pgpt->last_usable_lba),
-                       (unsigned long long)le64_to_cpu(agpt->last_usable_lba));
+			(u64)le64_to_cpu(pgpt->last_usable_lba),
+			(u64)le64_to_cpu(agpt->last_usable_lba));
 		error_found++;
 	}
 	if (efi_guidcmp(pgpt->disk_guid, agpt->disk_guid)) {
-		pr_warn("GPT:disk_guids don't match.\n");
+		pr_warn("GPT:disk_guids don't match\n");
 		error_found++;
 	}
 	if (le32_to_cpu(pgpt->num_partition_entries) !=
-            le32_to_cpu(agpt->num_partition_entries)) {
-		pr_warn("GPT:num_partition_entries don't match: "
-		       "0x%x != 0x%x\n",
-		       le32_to_cpu(pgpt->num_partition_entries),
-		       le32_to_cpu(agpt->num_partition_entries));
+	    le32_to_cpu(agpt->num_partition_entries)) {
+		pr_warn("GPT:num_partition_entries don't match: 0x%x != 0x%x\n",
+			le32_to_cpu(pgpt->num_partition_entries),
+			le32_to_cpu(agpt->num_partition_entries));
 		error_found++;
 	}
 	if (le32_to_cpu(pgpt->sizeof_partition_entry) !=
-            le32_to_cpu(agpt->sizeof_partition_entry)) {
-		pr_warn("GPT:sizeof_partition_entry values don't match: "
-		       "0x%x != 0x%x\n",
-                       le32_to_cpu(pgpt->sizeof_partition_entry),
-		       le32_to_cpu(agpt->sizeof_partition_entry));
+	    le32_to_cpu(agpt->sizeof_partition_entry)) {
+		pr_warn("GPT:sizeof_partition_entry values don't match: 0x%x != 0x%x\n",
+			le32_to_cpu(pgpt->sizeof_partition_entry),
+			le32_to_cpu(agpt->sizeof_partition_entry));
 		error_found++;
 	}
 	if (le32_to_cpu(pgpt->partition_entry_array_crc32) !=
-            le32_to_cpu(agpt->partition_entry_array_crc32)) {
-		pr_warn("GPT:partition_entry_array_crc32 values don't match: "
-		       "0x%x != 0x%x\n",
-                       le32_to_cpu(pgpt->partition_entry_array_crc32),
-		       le32_to_cpu(agpt->partition_entry_array_crc32));
+	    le32_to_cpu(agpt->partition_entry_array_crc32)) {
+		pr_warn("GPT:partition_entry_array_crc32 values don't match: 0x%x != 0x%x\n",
+			le32_to_cpu(pgpt->partition_entry_array_crc32),
+			le32_to_cpu(agpt->partition_entry_array_crc32));
 		error_found++;
 	}
 	if (le64_to_cpu(pgpt->alternate_lba) != lastlba) {
-		pr_warn("GPT:Primary header thinks Alt. header is not at the end of the disk.\n");
+		pr_warn("GPT:Primary header thinks Alt. header is not at the end of the disk\n");
 		pr_warn("GPT:%lld != %lld\n",
-			(unsigned long long)le64_to_cpu(pgpt->alternate_lba),
-			(unsigned long long)lastlba);
+			(u64)le64_to_cpu(pgpt->alternate_lba), lastlba);
 		error_found++;
 	}
 
 	if (le64_to_cpu(agpt->my_lba) != lastlba) {
-		pr_warn("GPT:Alternate GPT header not at the end of the disk.\n");
+		pr_warn("GPT:Alternate GPT header not at the end of the disk\n");
 		pr_warn("GPT:%lld != %lld\n",
-			(unsigned long long)le64_to_cpu(agpt->my_lba),
-			(unsigned long long)lastlba);
+			(u64)le64_to_cpu(agpt->my_lba), lastlba);
 		error_found++;
 	}
 
 	if (error_found)
-		pr_warn("GPT: Use GNU Parted to correct GPT errors.\n");
-	return;
+		pr_warn("GPT: Use GNU Parted to correct GPT errors\n");
 }
 
 /**
  * find_valid_gpt() - Search disk for valid GPT headers and PTEs
  * @state: disk parsed partitions
- * @gpt: GPT header ptr, filled on return.
- * @ptes: PTEs ptr, filled on return.
+ * @gpt: GPT header ptr, filled on successful return.
+ * @ptes: PTEs ptr, filled on successful return.
  *
  * Description: Returns 1 if valid, 0 on error.
  * If valid, returns pointers to newly allocated GPT header and PTEs.
@@ -583,18 +583,14 @@ compare_gpts(gpt_header *pgpt, gpt_header *agpt, u64 lastlba)
 static int find_valid_gpt(struct parsed_partitions *state, gpt_header **gpt,
 			  gpt_entry **ptes)
 {
-	int good_pgpt = 0, good_agpt = 0, good_pmbr = 0;
+	sector_t total_sectors = i_size_read(state->bdev->bd_inode) >> 9;
+	int good_pgpt, good_agpt = 0, good_pmbr = 0;
 	gpt_header *pgpt = NULL, *agpt = NULL;
 	gpt_entry *pptes = NULL, *aptes = NULL;
+	u64 lastlba = last_lba(state->bdev);
 	legacy_mbr *legacymbr;
-	sector_t total_sectors = i_size_read(state->bdev->bd_inode) >> 9;
-	u64 lastlba;
-
-	if (!ptes)
-		return 0;
 
-	lastlba = last_lba(state->bdev);
-        if (!force_gpt) {
+	if (!force_gpt) {
 		/* This will be added to the EFI Spec. per Intel after v1.02. */
 		legacymbr = kzalloc(sizeof(*legacymbr), GFP_KERNEL);
 		if (!legacymbr)
@@ -614,12 +610,12 @@ static int find_valid_gpt(struct parsed_partitions *state, gpt_header **gpt,
 
 	good_pgpt = is_gpt_valid(state, GPT_PRIMARY_PARTITION_TABLE_LBA,
 				 &pgpt, &pptes);
-        if (good_pgpt)
+	if (good_pgpt)
 		good_agpt = is_gpt_valid(state,
 					 le64_to_cpu(pgpt->alternate_lba),
 					 &agpt, &aptes);
-        if (!good_agpt && force_gpt)
-                good_agpt = is_gpt_valid(state, lastlba, &agpt, &aptes);
+	if (!good_agpt && force_gpt)
+		good_agpt = is_gpt_valid(state, lastlba, &agpt, &aptes);
 
 	/*
 	 * The force_gpt_sector is used by NVIDIA Tegra partition parser in
@@ -630,43 +626,42 @@ static int find_valid_gpt(struct parsed_partitions *state, gpt_header **gpt,
 		good_agpt = is_gpt_valid(state, state->force_gpt_sector,
 					 &agpt, &aptes);
 
-        /* The obviously unsuccessful case */
-        if (!good_pgpt && !good_agpt)
-                goto fail;
+	/* The obviously unsuccessful case */
+	if (!good_pgpt && !good_agpt)
+		goto fail;
 
-        compare_gpts(pgpt, agpt, lastlba);
+	compare_gpts(pgpt, agpt, lastlba);
 
-        /* The good cases */
-        if (good_pgpt) {
-                *gpt  = pgpt;
-                *ptes = pptes;
-                kfree(agpt);
-                kfree(aptes);
+	/* The good cases */
+	if (good_pgpt) {
+		*gpt  = pgpt;
+		*ptes = pptes;
+		kfree(agpt);
+		kfree(aptes);
 		if (!good_agpt)
-                        pr_warn("Alternate GPT is invalid, using primary GPT.\n");
-                return 1;
-        }
-        else if (good_agpt) {
-                *gpt  = agpt;
-                *ptes = aptes;
-                kfree(pgpt);
-                kfree(pptes);
-		pr_warn("Primary GPT is invalid, using alternate GPT.\n");
-                return 1;
-        }
-
- fail:
-        kfree(pgpt);
-        kfree(agpt);
-        kfree(pptes);
-        kfree(aptes);
-        *gpt = NULL;
-        *ptes = NULL;
-        return 0;
+			pr_warn("Alternate GPT is invalid, using primary GPT\n");
+		return 1;
+	}
+
+	if (good_agpt) {
+		*gpt  = agpt;
+		*ptes = aptes;
+		kfree(pgpt);
+		kfree(pptes);
+		pr_warn("Primary GPT is invalid, using alternate GPT\n");
+		return 1;
+	}
+
+fail:
+	kfree(pgpt);
+	kfree(agpt);
+	kfree(pptes);
+	kfree(aptes);
+	return 0;
 }
 
 /**
- * utf16_le_to_7bit(): Naively converts a UTF-16LE string to 7-bit ASCII characters
+ * utf16_le_to_7bit()
  * @in: input UTF-16LE string
  * @size: size of the input string
  * @out: output string ptr, should be capable to store @size+1 characters
@@ -713,20 +708,19 @@ int efi_partition(struct parsed_partitions *state)
 {
 	gpt_header *gpt = NULL;
 	gpt_entry *ptes = NULL;
-	u32 i;
-	unsigned ssz = bdev_logical_block_size(state->bdev) / 512;
+	unsigned int ssz = bdev_logical_block_size(state->bdev) / 512;
+	unsigned int num_partition_entries, i;
 
-	if (!find_valid_gpt(state, &gpt, &ptes) || !gpt || !ptes) {
-		kfree(gpt);
-		kfree(ptes);
+	if (!find_valid_gpt(state, &gpt, &ptes) || !gpt || !ptes)
 		return 0;
-	}
 
 	pr_debug("GUID Partition Table is valid!  Yea!\n");
 
-	for (i = 0; i < le32_to_cpu(gpt->num_partition_entries) && i < state->limit-1; i++) {
+	num_partition_entries = le32_to_cpu(gpt->num_partition_entries);
+
+	for (i = 0; i < num_partition_entries && i < state->limit - 1; i++) {
 		struct partition_meta_info *info;
-		unsigned label_max;
+		unsigned int label_max;
 		u64 start = le64_to_cpu(ptes[i].starting_lba);
 		u64 size = le64_to_cpu(ptes[i].ending_lba) -
 			   le64_to_cpu(ptes[i].starting_lba) + 1ULL;
@@ -734,10 +728,11 @@ int efi_partition(struct parsed_partitions *state)
 		if (!is_pte_valid(&ptes[i], last_lba(state->bdev)))
 			continue;
 
-		put_partition(state, i+1, start * ssz, size * ssz);
+		put_partition(state, i + 1, start * ssz, size * ssz);
 
 		/* If this is a RAID volume, tell md */
-		if (!efi_guidcmp(ptes[i].partition_type_guid, PARTITION_LINUX_RAID_GUID))
+		if (!efi_guidcmp(ptes[i].partition_type_guid,
+				 PARTITION_LINUX_RAID_GUID))
 			state->parts[i + 1].flags = ADDPART_FLAG_RAID;
 
 		info = &state->parts[i + 1].info;
@@ -746,7 +741,8 @@ int efi_partition(struct parsed_partitions *state)
 		/* Naively convert UTF16-LE to 7 bits. */
 		label_max = min(ARRAY_SIZE(info->volname) - 1,
 				ARRAY_SIZE(ptes[i].partition_name));
-		utf16_le_to_7bit(ptes[i].partition_name, label_max, info->volname);
+		utf16_le_to_7bit(ptes[i].partition_name, label_max,
+				 info->volname);
 		state->parts[i + 1].has_info = true;
 	}
 	kfree(ptes);
Signature · 1 line
2.26.0
#9 lore raw

PATCH v6 6/7 partitions/tegra: Support enforced GPT scanning

In reply to Dmitry Osipenko

Downstream NVIDIA bootloader provides gpt_sector=<sector> kernel command line option to the kernel. This option should instruct the GPT partition parser to look at the specified sector for a valid GPT header if the GPT is not found at the beginning or the end of a block device. Support of this feature is needed by Tegra-based devices that have TegraPT and GPT placed in inaccessible by kernel locations. The GPT entry duplicates TegraPT partitions.

Secondly, some Tegra-based devices have bootloader that enforces the GPT scanning of the backup/alternative GPT entry by providing "gpt" cmdline option to the kernel, but doesn't provide the "gpt_sector" option. In this case GPT entry resides at a special offset from the end of eMMC storage. It is a common situation for older bootloader versions.

The offset is calculated as a total number of eMMC sectors minus number of eMMC boot sectors minus 1. This equation is explicitly defined and used by the downstream Tegra kernels for locating GPT entry.

---
 block/partitions/check.h |  1 +
 block/partitions/core.c  |  1 +
 block/partitions/efi.c   |  9 +++++++
 block/partitions/tegra.c | 57 ++++++++++++++++++++++++++++++++++++++++
 4 files changed, 68 insertions(+)
block/partitions/check.h +1 -0
index 55acf6340e5b..1ce445d1c7f0 100644
@@ -68,5 +68,6 @@ int osf_partition(struct parsed_partitions *state);
 int sgi_partition(struct parsed_partitions *state);
 int sun_partition(struct parsed_partitions *state);
 int sysv68_partition(struct parsed_partitions *state);
+int tegra_partition_forced_gpt(struct parsed_partitions *state);
 int tegra_partition(struct parsed_partitions *state);
 int ultrix_partition(struct parsed_partitions *state);
block/partitions/core.c +1 -0
index 0b4720372f07..1931647d9742 100644
@@ -83,6 +83,7 @@ static int (*check_part[])(struct parsed_partitions *) = {
 	sysv68_partition,
 #endif
 #ifdef CONFIG_TEGRA_PARTITION
+	tegra_partition_forced_gpt,
 	tegra_partition,
 #endif
 	NULL
block/partitions/efi.c +9 -0
index f0229e7a6894..f8036fd55501 100644
@@ -101,6 +101,15 @@ static int force_gpt;
 static int __init
 force_gpt_fn(char *str)
 {
+	/*
+	 * This check allows to properly parse cmdline variants like
+	 * "gpt gpt_sector=<sector>" and "gpt_sector=<sector> gpt" since
+	 * "gpt" overlaps with the "gpt_sector=", see tegra_gpt_sector_fn().
+	 * The argument should be absent for a boolean cmdline option.
+	 */
+	if (strlen(str))
+		return 0;
+
 	force_gpt = 1;
 	return 1;
 }
block/partitions/tegra.c +57 -0

60 lines not on this page · raw message

Signature · 1 line
2.26.0
#10 lore raw

PATCH v6 7/7 soc/tegra: Expose Boot Configuration Table via sysfs

In reply to Dmitry Osipenko

It's quite useful to have unencrypted BCT exposed to userspace for debugging purposes, so let's expose it via sysfs. The BCT data will be present in '/sys/tegra/boot_config_table' binary file if BCT is available.

---
 arch/arm/mach-tegra/tegra.c  |  4 +++
 drivers/soc/tegra/Makefile   |  1 +
 drivers/soc/tegra/bootdata.c | 51 ++++++++++++++++++++++++++++++++++++
 drivers/soc/tegra/common.c   | 17 ++++++++++++
 include/soc/tegra/bootdata.h |  2 ++
 include/soc/tegra/common.h   |  3 +++
 6 files changed, 78 insertions(+)
 create mode 100644 drivers/soc/tegra/bootdata.c
arch/arm/mach-tegra/tegra.c +4 -0
index da6bcd85398b..5f40463f1b97 100644
@@ -72,6 +72,7 @@ static void __init tegra_boot_config_table_init(void)
 	u32 iram_end   = TEGRA_IRAM_BASE + TEGRA_IRAM_SIZE;
 	u32 iram_start = TEGRA_IRAM_BASE;
 	u32 pt_addr, pt_size, bct_size;
+	void __iomem *bct_ptr;
 
 	t20_bit = IO_ADDRESS(TEGRA_IRAM_BASE);
 
@@ -90,6 +91,7 @@ static void __init tegra_boot_config_table_init(void)
 
 		pt_addr = t20_bct->partition_table_logical_sector_address;
 		pt_size = t20_bct->partition_table_num_logical_sectors;
+		bct_ptr = t20_bct;
 
 	} else if (of_machine_is_compatible("nvidia,tegra30")) {
 		bct_size = sizeof(*t30_bct);
@@ -106,12 +108,14 @@ static void __init tegra_boot_config_table_init(void)
 
 		pt_addr = t30_bct->partition_table_logical_sector_address;
 		pt_size = t30_bct->partition_table_num_logical_sectors;
+		bct_ptr = t30_bct;
 	} else {
 		return;
 	}
 
 	pr_info("%s: BCT found in IRAM\n", __func__);
 
+	tegra_bootdata_bct_setup(bct_ptr, bct_size);
 	tegra_partition_table_setup(pt_addr, pt_size);
 }
 
drivers/soc/tegra/Makefile +1 -0
index 9c809c1814bd..8be2bfb4d95d 100644
@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: GPL-2.0
 obj-y += fuse/
 
+obj-y += bootdata.o
 obj-y += common.o
 obj-$(CONFIG_SOC_TEGRA_FLOWCTRL) += flowctrl.o
 obj-$(CONFIG_SOC_TEGRA_PMC) += pmc.o
drivers/soc/tegra/bootdata.c new file +51 -0

51 lines not on this page · raw message

drivers/soc/tegra/common.c +17 -0
index 3dc54f59cafe..2b4b49eacb2e 100644
@@ -3,10 +3,15 @@
  * Copyright (C) 2014 NVIDIA CORPORATION.  All rights reserved.
  */
 
+#include <linux/init.h>
+#include <linux/kernel.h>
 #include <linux/of.h>
+#include <linux/sysfs.h>
 
 #include <soc/tegra/common.h>
 
+struct kobject *tegra_soc_kobj;
+
 static const struct of_device_id tegra_machine_match[] = {
 	{ .compatible = "nvidia,tegra20", },
 	{ .compatible = "nvidia,tegra30", },
@@ -31,3 +36,15 @@ bool soc_is_tegra(void)
 
 	return match != NULL;
 }
+
+static int __init tegra_soc_sysfs_init(void)
+{
+	if (!soc_is_tegra())
+		return 0;
+
+	tegra_soc_kobj = kobject_create_and_add("tegra", NULL);
+	WARN_ON(!tegra_soc_kobj);
+
+	return 0;
+}
+arch_initcall(tegra_soc_sysfs_init)
include/soc/tegra/bootdata.h +2 -0
index 7be207cb2519..d5c7a251517d 100644
@@ -43,4 +43,6 @@ struct tegra30_boot_config_table {
 	u32 unused_data[3];
 } __packed;
 
+void tegra_bootdata_bct_setup(void __iomem *bct_ptr, size_t bct_size);
+
 #endif /* __SOC_TEGRA_BOOTDATA_H__ */
include/soc/tegra/common.h +3 -0
index 744280ecab5f..0bc11b45c98e 100644
@@ -7,8 +7,11 @@
 #define __SOC_TEGRA_COMMON_H__
 
 #include <linux/types.h>
+#include <linux/sysfs.h>
 
 #ifdef CONFIG_ARCH_TEGRA
+extern struct kobject *tegra_soc_kobj;
+
 bool soc_is_tegra(void);
 #else
 static inline bool soc_is_tegra(void)
Signature · 1 line
2.26.0
#3 lore raw

Re: [PATCH v6 2/7] mmc: block: Add mmc_bdev_to_card() helper

In reply to Dmitry Osipenko

17.05.2020 05:12, Dmitry Osipenko пишет:

Quoted 58 lines

NVIDIA Tegra Partition Table takes into account MMC card's BOOT_SIZE_MULT parameter, and thus, the partition parser needs to retrieve that EXT_CSD value from the block device. There are also some other parts of struct mmc_card that are needed for the partition parser in order to calculate the eMMC offset and verify different things. This patch introduces new helper which takes block device for the input argument and returns the corresponding MMC card.

---
 drivers/mmc/core/block.c   | 15 +++++++++++++++
 include/linux/mmc/blkdev.h | 13 +++++++++++++
 2 files changed, 28 insertions(+)
 create mode 100644 include/linux/mmc/blkdev.h
drivers/mmc/core/block.c +15 -0
index c5367e2c8487..99298e888381 100644
@@ -40,6 +40,7 @@
 #include <linux/debugfs.h>
 
 #include <linux/mmc/ioctl.h>
+#include <linux/mmc/blkdev.h>
 #include <linux/mmc/card.h>
 #include <linux/mmc/host.h>
 #include <linux/mmc/mmc.h>
@@ -305,6 +306,20 @@ static ssize_t force_ro_store(struct device *dev, struct device_attribute *attr,
 	return ret;
 }
 
+struct mmc_card *mmc_bdev_to_card(struct block_device *bdev)
+{
+	struct mmc_blk_data *md;
+
+	if (bdev->bd_disk->major != MMC_BLOCK_MAJOR)
+		return NULL;
+
+	md = mmc_blk_get(bdev->bd_disk);
+	if (!md)
+		return NULL;
+
+	return md->queue.card;
+}
+
 static int mmc_blk_open(struct block_device *bdev, fmode_t mode)
 {
 	struct mmc_blk_data *md = mmc_blk_get(bdev->bd_disk);
include/linux/mmc/blkdev.h new file +3 -0
new file mode 100644
index 000000000000..67608c58de70
@@ -0,0 +1,13 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ *  linux/include/linux/mmc/blkdev.h

include/linux/mmc/blkdev.h line 13

Quoted 10 lines
include/linux/mmc/blkdev.h new file +10 -0
+ */
+#ifndef LINUX_MMC_BLOCK_DEVICE_H
+#define LINUX_MMC_BLOCK_DEVICE_H
+
+struct block_device;
+struct mmc_card;
+
+struct mmc_card *mmc_bdev_to_card(struct block_device *bdev);
+
+#endif /* LINUX_MMC_BLOCK_DEVICE_H */

Hello Ulf / Jens and everyone,

Guys, what do you think about this change?

Currently it's not allowed to compile MMC_BLOCK as a loadable kernel module if TEGRA_PARTITION is enabled because it depends on MMC_BLOCK presence. I'm curious if this situation could be improved by moving mmc_bdev_to_card() to linux/mmc/blkdev.h and then:

1. Moving all private mmc/core/block.c structs to the public linux/mmc/blkdev.h.

2. Or adding a "private opaque" pointer to a struct block_device and setting it to md->queue.card, for example.

3. I see that struct block_device already has some bd_private field, but I'm not sure whether it could be used for what I'm trying to achieve. Actually I don't see where bd_private is used in kernel at all.

I'd like get yours feedback, thanks in advance.

#4 lore raw

Re: [PATCH v6 2/7] mmc: block: Add mmc_bdev_to_card() helper

Quoted 64 lines · Dmitry Osipenko

17.05.2020 05:12, Dmitry Osipenko пишет:

Quoted 62 lines

NVIDIA Tegra Partition Table takes into account MMC card's BOOT_SIZE_MULT parameter, and thus, the partition parser needs to retrieve that EXT_CSD value from the block device. There are also some other parts of struct mmc_card that are needed for the partition parser in order to calculate the eMMC offset and verify different things. This patch introduces new helper which takes block device for the input argument and returns the corresponding MMC card.

---
 drivers/mmc/core/block.c   | 15 +++++++++++++++
 include/linux/mmc/blkdev.h | 13 +++++++++++++
 2 files changed, 28 insertions(+)
 create mode 100644 include/linux/mmc/blkdev.h
drivers/mmc/core/block.c +15 -0
index c5367e2c8487..99298e888381 100644
@@ -40,6 +40,7 @@
 #include <linux/debugfs.h>
 
 #include <linux/mmc/ioctl.h>
+#include <linux/mmc/blkdev.h>
 #include <linux/mmc/card.h>
 #include <linux/mmc/host.h>
 #include <linux/mmc/mmc.h>
@@ -305,6 +306,20 @@ static ssize_t force_ro_store(struct device *dev, struct device_attribute *attr,
      return ret;
 }
 
+struct mmc_card *mmc_bdev_to_card(struct block_device *bdev)
+{
+     struct mmc_blk_data *md;
+
+     if (bdev->bd_disk->major != MMC_BLOCK_MAJOR)
+             return NULL;
+
+     md = mmc_blk_get(bdev->bd_disk);
+     if (!md)
+             return NULL;
+
+     return md->queue.card;
+}
+
 static int mmc_blk_open(struct block_device *bdev, fmode_t mode)
 {
      struct mmc_blk_data *md = mmc_blk_get(bdev->bd_disk);
include/linux/mmc/blkdev.h new file +8 -0
new file mode 100644
index 000000000000..67608c58de70
@@ -0,0 +1,13 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ *  linux/include/linux/mmc/blkdev.h
+ */
+#ifndef LINUX_MMC_BLOCK_DEVICE_H
+#define LINUX_MMC_BLOCK_DEVICE_H
+
+struct block_device;
Quoted 8 lines

include/linux/mmc/blkdev.h line 13

Quoted 6 lines
include/linux/mmc/blkdev.h new file +5 -0
+struct mmc_card;
+
+struct mmc_card *mmc_bdev_to_card(struct block_device *bdev);
+
+#endif /* LINUX_MMC_BLOCK_DEVICE_H */

Hello Ulf / Jens and everyone,

Hi Dmitry,

Quoted 2 lines

Guys, what do you think about this change?

As I stated in an earlier reply, I am deferring the review from mmc point of view, until I see some confirmation from Jens that he is okay with adding a new partition format.

Otherwise I may just waste my time on reviews. I hope you understand.

Kind regards
Uffe

Quoted 17 lines

Currently it's not allowed to compile MMC_BLOCK as a loadable kernel module if TEGRA_PARTITION is enabled because it depends on MMC_BLOCK presence. I'm curious if this situation could be improved by moving mmc_bdev_to_card() to linux/mmc/blkdev.h and then:

1. Moving all private mmc/core/block.c structs to the public linux/mmc/blkdev.h.

2. Or adding a "private opaque" pointer to a struct block_device and setting it to md->queue.card, for example.

3. I see that struct block_device already has some bd_private field, but I'm not sure whether it could be used for what I'm trying to achieve. Actually I don't see where bd_private is used in kernel at all.

I'd like get yours feedback, thanks in advance.

#5 lore raw

Re: [PATCH v6 2/7] mmc: block: Add mmc_bdev_to_card() helper

18.05.2020 10:24, Ulf Hansson пишет:

Quoted 77 lines · Dmitry Osipenko
Quoted 64 lines

17.05.2020 05:12, Dmitry Osipenko пишет:

Quoted 62 lines

NVIDIA Tegra Partition Table takes into account MMC card's BOOT_SIZE_MULT parameter, and thus, the partition parser needs to retrieve that EXT_CSD value from the block device. There are also some other parts of struct mmc_card that are needed for the partition parser in order to calculate the eMMC offset and verify different things. This patch introduces new helper which takes block device for the input argument and returns the corresponding MMC card.

---
 drivers/mmc/core/block.c   | 15 +++++++++++++++
 include/linux/mmc/blkdev.h | 13 +++++++++++++
 2 files changed, 28 insertions(+)
 create mode 100644 include/linux/mmc/blkdev.h
drivers/mmc/core/block.c +15 -0
index c5367e2c8487..99298e888381 100644
@@ -40,6 +40,7 @@
 #include <linux/debugfs.h>
 
 #include <linux/mmc/ioctl.h>
+#include <linux/mmc/blkdev.h>
 #include <linux/mmc/card.h>
 #include <linux/mmc/host.h>
 #include <linux/mmc/mmc.h>
@@ -305,6 +306,20 @@ static ssize_t force_ro_store(struct device *dev, struct device_attribute *attr,
      return ret;
 }
 
+struct mmc_card *mmc_bdev_to_card(struct block_device *bdev)
+{
+     struct mmc_blk_data *md;
+
+     if (bdev->bd_disk->major != MMC_BLOCK_MAJOR)
+             return NULL;
+
+     md = mmc_blk_get(bdev->bd_disk);
+     if (!md)
+             return NULL;
+
+     return md->queue.card;
+}
+
 static int mmc_blk_open(struct block_device *bdev, fmode_t mode)
 {
      struct mmc_blk_data *md = mmc_blk_get(bdev->bd_disk);
include/linux/mmc/blkdev.h new file +8 -0
new file mode 100644
index 000000000000..67608c58de70
@@ -0,0 +1,13 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ *  linux/include/linux/mmc/blkdev.h
+ */
+#ifndef LINUX_MMC_BLOCK_DEVICE_H
+#define LINUX_MMC_BLOCK_DEVICE_H
+
+struct block_device;
Quoted 8 lines

include/linux/mmc/blkdev.h line 13

Quoted 6 lines
include/linux/mmc/blkdev.h new file +5 -0
+struct mmc_card;
+
+struct mmc_card *mmc_bdev_to_card(struct block_device *bdev);
+
+#endif /* LINUX_MMC_BLOCK_DEVICE_H */

Hello Ulf / Jens and everyone,

Hi Dmitry,

Quoted 1 line
Quoted 7 lines
Quoted 1 line

Guys, what do you think about this change?

As I stated in an earlier reply, I am deferring the review from mmc point of view, until I see some confirmation from Jens that he is okay with adding a new partition format.

Otherwise I may just waste my time on reviews. I hope you understand.

Hello Ulf,

I understand yours concerns. However, since the v6 of this series, the information about MMC card is also needed if we'll want to support devices that have GPT entry and use an older bootloader version.

Jens, could you please let us know whether we aren't wasting our time here? :) If it's not desirable to support hacks that are needed for consumer-grade Tegra-based Android devices in upstream kernel for the case of the eMMC storage, then I'll stop this effort and won't bother you again with these patches.