Change in flashrom[master]: tests: test write protection

[Anastasia Klimchuk (Code Review)]

Anastasia Klimchuk has submitted this change. ( https://review.coreboot.org/c/flashrom/+/59075 )

Change subject: tests: test write protection
......................................................................

tests: test write protection

Tests both WP implementation and its emulation in dummy programmer.

Change-Id: I49af7f6d173eb4c56c22d80b01a473b8c499c0f8
Signed-off-by: Sergii Dmytruk 
Reviewed-on: https://review.coreboot.org/c/flashrom/+/59075
Tested-by: build bot (Jenkins) 
Reviewed-by: Thomas Heijligen 
Reviewed-by: Anastasia Klimchuk 
Reviewed-by: Edward O'Callaghan 
---
A tests/chip_wp.c
M tests/meson.build
M tests/tests.c
M tests/tests.h
4 files changed, 344 insertions(+), 0 deletions(-)

Approvals:
  build bot (Jenkins): Verified
  Thomas Heijligen: Looks good to me, approved
  Edward O'Callaghan: Looks good to me, approved
  Anastasia Klimchuk: Looks good to me, approved

diff --git a/tests/chip_wp.c b/tests/chip_wp.c
new file mode 100644
index 0000000..8b209bd
--- /dev/null
+++ b/tests/chip_wp.c
@@ -0,0 +1,325 @@
+/*
+ * This file is part of the flashrom project.
+ *
+ * Copyright (C) 2021 3mdeb Embedded Systems Consulting
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <include/test.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "chipdrivers.h"
+#include "flash.h"
+#include "libflashrom.h"
+#include "programmer.h"
+#include "tests.h"
+
+/*
+ * Tests in this file do not use any mocking, because using write-protect
+ * emulation in dummyflasher programmer is sufficient
+ */
+
+#define LAYOUT_TAIL_REGION_START 0x1000
+
+static void setup_chip(struct flashrom_flashctx *flash, struct flashrom_layout **layout,
+		       struct flashchip *chip, const char *programmer_param)
+{
+	flash->chip = chip;
+
+	if (layout) {
+		const size_t tail_start = LAYOUT_TAIL_REGION_START;
+		const size_t tail_len = chip->total_size * KiB - 1;
+
+		assert_int_equal(0, flashrom_layout_new(layout));
+		assert_int_equal(0, flashrom_layout_add_region(*layout, 0, tail_start - 1, "head"));
+		assert_int_equal(0, flashrom_layout_add_region(*layout, tail_start, tail_len, "tail"));
+
+		flashrom_layout_set(flash, *layout);
+	}
+
+	assert_int_equal(0, programmer_init(&programmer_dummy, programmer_param));
+	/* Assignment below normally happens while probing, but this test is not probing. */
+	flash->mst = &registered_masters[0];
+}
+
+static void teardown(struct flashrom_layout **layout)
+{
+	assert_int_equal(0, programmer_shutdown());
+	if (layout)
+		flashrom_layout_release(*layout);
+}
+
+/* Setup the struct for W25Q128.V, all values come from flashchips.c */
+static const struct flashchip chip_W25Q128_V = {
+	.vendor		= "aklm&dummyflasher",
+	.total_size	= 16 * 1024,
+	.tested		= TEST_OK_PREW,
+	.read		= spi_chip_read,
+	.write		= spi_chip_write_256,
+	.unlock         = spi_disable_blockprotect,
+	.feature_bits	= FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_WRSR2,
+	.block_erasers  =
+	{
+		{
+			.eraseblocks = { {4 * 1024, 4096} },
+			.block_erase = spi_block_erase_20,
+		}, {
+			.eraseblocks = { {32 * 1024, 512} },
+			.block_erase = spi_block_erase_52,
+		}, {
+			.eraseblocks = { {64 * 1024, 256} },
+			.block_erase = spi_block_erase_d8,
+		}, {
+			.eraseblocks = { {16 * 1024 * 1024, 1} },
+			.block_erase = spi_block_erase_60,
+		}, {
+			.eraseblocks = { {16 * 1024 * 1024, 1} },
+			.block_erase = spi_block_erase_c7,
+		}
+	},
+	.reg_bits	=
+	{
+		.srp    = {STATUS1, 7, RW},
+		.srl    = {STATUS2, 0, RW},
+		.bp     = {{STATUS1, 2, RW}, {STATUS1, 3, RW}, {STATUS1, 4, RW}},
+		.tb     = {STATUS1, 5, RW},
+		.sec    = {STATUS1, 6, RW},
+		.cmp    = {STATUS2, 6, RW},
+		.wps    = {STATUS3, 2, RW},
+	},
+	.decode_range	= decode_range_spi25,
+};
+
+/* Trying to set an unsupported WP range fails */
+void invalid_wp_range_dummyflasher_test_success(void **state)
+{
+	(void) state; /* unused */
+
+	char *param_dup = strdup("bus=spi,emulate=W25Q128FV,hwwp=no");
+
+	struct flashrom_flashctx flash = { 0 };
+	struct flashchip mock_chip = chip_W25Q128_V;
+	struct flashrom_wp_cfg *wp_cfg;
+
+	setup_chip(&flash, NULL, &mock_chip, param_dup);
+
+	assert_int_equal(0, flashrom_wp_cfg_new(&wp_cfg));
+	flashrom_wp_set_mode(wp_cfg, FLASHROM_WP_MODE_HARDWARE);
+	flashrom_wp_set_range(wp_cfg, 0x1000, 0x1000);
+
+	assert_int_equal(FLASHROM_WP_ERR_RANGE_UNSUPPORTED, flashrom_wp_write_cfg(&flash, wp_cfg));
+
+	teardown(NULL);
+
+	flashrom_wp_cfg_release(wp_cfg);
+	free(param_dup);
+}
+
+/* Enabling hardware WP with a valid range succeeds */
+void set_wp_range_dummyflasher_test_success(void **state)
+{
+	(void) state; /* unused */
+
+	char *param_dup = strdup("bus=spi,emulate=W25Q128FV,hwwp=no");
+
+	struct flashrom_flashctx flash = { 0 };
+	struct flashchip mock_chip = chip_W25Q128_V;
+	struct flashrom_wp_cfg *wp_cfg;
+
+	size_t start;
+	size_t len;
+
+	setup_chip(&flash, NULL, &mock_chip, param_dup);
+
+	/* Use last 4 KiB for a range. */
+	assert_int_equal(0, flashrom_wp_cfg_new(&wp_cfg));
+	flashrom_wp_set_mode(wp_cfg, FLASHROM_WP_MODE_HARDWARE);
+	flashrom_wp_set_range(wp_cfg, mock_chip.total_size * KiB - 4 * KiB, 4 * KiB);
+
+	assert_int_equal(0, flashrom_wp_write_cfg(&flash, wp_cfg));
+
+	/* Check that range was set correctly. */
+	assert_int_equal(0, flashrom_wp_read_cfg(wp_cfg, &flash));
+	flashrom_wp_get_range(&start, &len, wp_cfg);
+	assert_int_equal(16 * MiB - 4 * KiB, start);
+	assert_int_equal(4 * KiB, len);
+
+	teardown(NULL);
+
+	flashrom_wp_cfg_release(wp_cfg);
+	free(param_dup);
+}
+
+/* Enable hardware WP and verify that it can not be unset */
+void switch_wp_mode_dummyflasher_test_success(void **state)
+{
+	(void) state; /* unused */
+
+	char *param_dup = strdup("bus=spi,emulate=W25Q128FV,hwwp=yes");
+
+	struct flashrom_flashctx flash = { 0 };
+	struct flashchip mock_chip = chip_W25Q128_V;
+	struct flashrom_wp_cfg *wp_cfg;
+
+	setup_chip(&flash, NULL, &mock_chip, param_dup);
+
+	assert_int_equal(0, flashrom_wp_cfg_new(&wp_cfg));
+
+	/* Check initial mode. */
+	assert_int_equal(0, flashrom_wp_read_cfg(wp_cfg, &flash));
+	assert_int_equal(FLASHROM_WP_MODE_DISABLED, flashrom_wp_get_mode(wp_cfg));
+
+	/* Enable hardware protection, which can't be unset because simulated
+	   HW WP pin is in active state. */
+	flashrom_wp_set_mode(wp_cfg, FLASHROM_WP_MODE_HARDWARE);
+	assert_int_equal(0, flashrom_wp_write_cfg(&flash, wp_cfg));
+	assert_int_equal(0, flashrom_wp_read_cfg(wp_cfg, &flash));
+	assert_int_equal(FLASHROM_WP_MODE_HARDWARE, flashrom_wp_get_mode(wp_cfg));
+
+	/* Check that write-protection mode can't be unset. */
+	flashrom_wp_set_mode(wp_cfg, FLASHROM_WP_MODE_DISABLED);
+	assert_int_equal(FLASHROM_WP_ERR_VERIFY_FAILED, flashrom_wp_write_cfg(&flash, wp_cfg));
+
+	/* Final mode should be "hardware". */
+	assert_int_equal(0, flashrom_wp_read_cfg(wp_cfg, &flash));
+	assert_int_equal(FLASHROM_WP_MODE_HARDWARE, flashrom_wp_get_mode(wp_cfg));
+
+	teardown(NULL);
+
+	flashrom_wp_cfg_release(wp_cfg);
+	free(param_dup);
+}
+
+/* WP state is decoded correctly from status registers */
+void wp_init_from_status_dummyflasher_test_success(void **state)
+{
+	(void) state; /* unused */
+
+	/*
+	 * CMP  (S14) = 1 (range complement)
+	 * SRP1 (S8)  = 1
+	 * SRP0 (S7)  = 1 (`SRP1 == 1 && SRP0 == 1` is permanent mode)
+	 * SEC  (S6)  = 1 (base unit is a 4 KiB sector)
+	 * TB   (S5)  = 1 (bottom up range)
+	 * BP2  (S4)  = 0
+	 * BP1  (S3)  = 1
+	 * BP0  (S2)  = 1 (bp: BP2-0 == 0b011 == 3)
+	 *
+	 * Range coefficient is `2 ** (bp - 1)`, which is 4 in this case.
+	 * Multiplaying that by base unit gives 16 KiB protected region at the
+	 * bottom (start of the chip), which is then complemented.
+	 */
+	char *param_dup = strdup("bus=spi,emulate=W25Q128FV,spi_status=0x41ec");
+
+	struct flashrom_flashctx flash = { 0 };
+	struct flashchip mock_chip = chip_W25Q128_V;
+	struct flashrom_wp_cfg *wp_cfg;
+
+	size_t start;
+	size_t len;
+
+	setup_chip(&flash, NULL, &mock_chip, param_dup);
+
+	assert_int_equal(0, flashrom_wp_cfg_new(&wp_cfg));
+
+	/* Verify that WP mode reflects SPI status */
+	assert_int_equal(0, flashrom_wp_read_cfg(wp_cfg, &flash));
+	assert_int_equal(FLASHROM_WP_MODE_PERMANENT, flashrom_wp_get_mode(wp_cfg));
+	flashrom_wp_get_range(&start, &len, wp_cfg);
+	assert_int_equal(0x004000, start);
+	assert_int_equal(0xffc000, len);
+
+	teardown(NULL);
+
+	flashrom_wp_cfg_release(wp_cfg);
+	free(param_dup);
+}
+
+/* Enabled WP makes full chip erasure fail */
+void full_chip_erase_with_wp_dummyflasher_test_success(void **state)
+{
+	(void) state; /* unused */
+
+	struct flashrom_flashctx flash = { 0 };
+	struct flashrom_layout *layout;
+	struct flashchip mock_chip = chip_W25Q128_V;
+	struct flashrom_wp_cfg *wp_cfg;
+
+	char *param_dup = strdup("bus=spi,emulate=W25Q128FV,hwwp=yes");
+
+	setup_chip(&flash, &layout, &mock_chip, param_dup);
+	/* Layout regions are created by setup_chip(). */
+	assert_int_equal(0, flashrom_layout_include_region(layout, "head"));
+	assert_int_equal(0, flashrom_layout_include_region(layout, "tail"));
+
+	assert_int_equal(0, flashrom_wp_cfg_new(&wp_cfg));
+
+	/* Write protection takes effect only after changing SRP values, so at
+	   this stage WP is not enabled and erase completes successfully. */
+	assert_int_equal(0, flashrom_flash_erase(&flash));
+
+	assert_int_equal(0, flashrom_wp_read_cfg(wp_cfg, &flash));
+
+	/* Hardware-protect first 4 KiB. */
+	flashrom_wp_set_range(wp_cfg, 0, 4 * KiB);
+	flashrom_wp_set_mode(wp_cfg, FLASHROM_WP_MODE_HARDWARE);
+
+	assert_int_equal(0, flashrom_wp_write_cfg(&flash, wp_cfg));
+
+	/* Try erasing the chip again. Now that WP is active, the first 4 KiB is
+	   protected and we're trying to erase the whole chip, erase should
+	   fail. */
+	assert_int_equal(1, flashrom_flash_erase(&flash));
+
+	teardown(&layout);
+
+	flashrom_wp_cfg_release(wp_cfg);
+	free(param_dup);
+}
+
+/* Enabled WP does not block erasing unprotected parts of the chip */
+void partial_chip_erase_with_wp_dummyflasher_test_success(void **state)
+{
+	(void) state; /* unused */
+
+	struct flashrom_flashctx flash = { 0 };
+	struct flashrom_layout *layout;
+	struct flashchip mock_chip = chip_W25Q128_V;
+	struct flashrom_wp_cfg *wp_cfg;
+
+	char *param_dup = strdup("bus=spi,emulate=W25Q128FV,hwwp=yes");
+
+	setup_chip(&flash, &layout, &mock_chip, param_dup);
+	/* Layout region is created by setup_chip(). */
+	assert_int_equal(0, flashrom_layout_include_region(layout, "tail"));
+
+	assert_int_equal(0, flashrom_wp_cfg_new(&wp_cfg));
+
+	assert_int_equal(0, flashrom_wp_read_cfg(wp_cfg, &flash));
+
+	/* Hardware-protect head region. */
+	flashrom_wp_set_mode(wp_cfg, FLASHROM_WP_MODE_HARDWARE);
+	flashrom_wp_set_range(wp_cfg, 0, LAYOUT_TAIL_REGION_START);
+
+	assert_int_equal(0, flashrom_wp_write_cfg(&flash, wp_cfg));
+
+	/* First 4 KiB is the only protected part of the chip and the region
+	   we included covers only unprotected part, so erase operation should
+	   succeed. */
+	assert_int_equal(0, flashrom_flash_erase(&flash));
+
+	teardown(&layout);
+
+	flashrom_wp_cfg_release(wp_cfg);
+	free(param_dup);
+}
diff --git a/tests/meson.build b/tests/meson.build
index d3b46b1..588ac17 100644
--- a/tests/meson.build
+++ b/tests/meson.build
@@ -23,6 +23,7 @@
   'lifecycle.c',
   'layout.c',
   'chip.c',
+  'chip_wp.c',
 ]

mocks = [
diff --git a/tests/tests.c b/tests/tests.c
index 6aabd90..2f955ff 100644
--- a/tests/tests.c
+++ b/tests/tests.c
@@ -436,5 +436,15 @@
    };
    ret |= cmocka_run_group_tests_name("chip.c tests", chip_tests, NULL, NULL);

+	const struct CMUnitTest chip_wp_tests[] = {
+		cmocka_unit_test(invalid_wp_range_dummyflasher_test_success),
+		cmocka_unit_test(set_wp_range_dummyflasher_test_success),
+		cmocka_unit_test(switch_wp_mode_dummyflasher_test_success),
+		cmocka_unit_test(wp_init_from_status_dummyflasher_test_success),
+		cmocka_unit_test(full_chip_erase_with_wp_dummyflasher_test_success),
+		cmocka_unit_test(partial_chip_erase_with_wp_dummyflasher_test_success),
+	};
+	ret |= cmocka_run_group_tests_name("chip_wp.c tests", chip_wp_tests, NULL, NULL);
+
    return ret;
 }
diff --git a/tests/tests.h b/tests/tests.h
index 68f7781..89e4095 100644
--- a/tests/tests.h
+++ b/tests/tests.h
@@ -68,4 +68,12 @@
 void verify_chip_test_success(void **state);
 void verify_chip_with_dummyflasher_test_success(void **state);

+/* chip_wp.c */
+void invalid_wp_range_dummyflasher_test_success(void **state);
+void set_wp_range_dummyflasher_test_success(void **state);
+void switch_wp_mode_dummyflasher_test_success(void **state);
+void wp_init_from_status_dummyflasher_test_success(void **state);
+void full_chip_erase_with_wp_dummyflasher_test_success(void **state);
+void partial_chip_erase_with_wp_dummyflasher_test_success(void **state);
+
 #endif /* TESTS_H */