From: "Michael Walle" <mwalle@kernel.org>
To: "Itai Handler" <itai.handler@gmail.com>, <pratyush@kernel.org>
Cc: <miquel.raynal@bootlin.com>, <richard@nod.at>, <vigneshr@ti.com>,
<takahiro.kuwano@infineon.com>, <tudor.ambarus@linaro.org>,
<linux-mtd@lists.infradead.org>, <linux-kernel@vger.kernel.org>,
<stable@vger.kernel.org>
Subject: Re: [PATCH v5] mtd: spi-nor: take the flash lock around spi_nor_restore()
Date: Wed, 18 Nov 2026 14:33:44 +0100 [thread overview]
Message-ID: <DMYDITU0H48Z.2LA5KF2TFNUY2@kernel.org> (raw)
In-Reply-To: <20261029210153.3986211-1-itai.handler@gmail.com>
[-- Attachment #1: Type: text/plain, Size: 11400 bytes --]
On Thu Oct 29, 2026 at 10:01 PM CET, Itai Handler wrote:
> spi_nor_restore() runs on reboot, kexec and unbind to hand the flash
> over in its power-on state. It runs without nor->lock while the MTD
> device is still registered. Tasks are not frozen on reboot or kexec,
> and kexec -e does not even stop user space, so the restore can run in
> the middle of a program or erase. This causes two problems:
>
> 1. The flash can be left in the wrong state. On boards that do not
> reset the flash (broken-flash-reset), the restore exits 4-byte
> address mode, but a busy flash typically ignores the command, so
> the flash stays in 4-byte mode after the reboot or kexec. After a
> reboot, a boot ROM that reads the flash in the power-on 3-byte mode
> gets the wrong data, and the board fails to boot. For example, the
> GnuBee PC1 (MT7621) has a Winbond W25Q256FV, which ignores the exit
> command while busy, and the board needs the restore to reboot, see
> commit 90dedc973b86 ("staging: mt7621-dts: allow gnubee to reboot
> cleanly."). A busy flash also ignores READ ID, so if it is still
> busy when the secondary kernel probes it after a kexec, the probe
> fails ("unrecognized JEDEC id bytes"), and that kernel cannot use
> the flash.
>
> 2. Data can be corrupted. The restore also soft resets flashes that
> support it, which can abort a program or erase. For example, the
> Micron MT25QU512ABB8ESF-0SIT QSPI NOR flash advertises the soft
> reset in its SFDP, and its data sheet says that a reset aborts a
> program or erase in progress and may corrupt data. If an application
> is writing data to the device when the system kexecs into a secondary
> kernel, or restarts, a sector can be left partly erased or programmed.
>
> Take the lock, so that the restore waits for the operation in flight.
> That alone is not enough: the next operation would then start right
> after the restore, and could still be running at the kexec or be cut
> short by the reboot. And after an exit from 4-byte mode, it would still
> use 4-byte addresses, so a page program would write to the wrong place.
> So mark the flash shut down before releasing the lock, and fail later
> operations with -ESHUTDOWN. The CFI drivers also refuse operations once
> they have reset the flash for a reboot (see cfi_intelext_reset()). If
> the SPI controller removes itself on shutdown, spi_nor_remove() runs
> after spi_nor_shutdown(), finds the flash shut down, and does not
> restore it a second time.
>
> The wait is usually short, as applications and flash file systems
> typically submit small requests, such as a single sector erase. It can
> be long, though: spi_nor_erase() holds the lock for the whole request,
> so shutdown or unbind may wait for a full chip erase, which can take
> minutes. If the lock cannot be taken, warn and restore without it, as
> before.
>
> Backport note: before v6.4, the lock helper is spi_nor_lock_and_prep(),
> and it has no _pe and _rd variants. From v6.4 on, apply this on top of
> commit f594a33f9721 ("mtd: spi-nor: Unprepare legacy controllers upon
> RWW wait interruption"), which is also tagged for stable.
>
> Fixes: 59b356ffd0b0 ("mtd: m25p80: restore the status of SPI flash when exiting")
> Cc: stable@vger.kernel.org # see patch description, needs adjustments for <= 6.3
> Assisted-by: LLM
> Signed-off-by: Itai Handler <itai.handler@gmail.com>
> ---
> Changes in v5:
> - Fail operations after the restore with -ESHUTDOWN, so that none can
> reach the flash between the restore and the reboot or kexec.
> - Warn and restore anyway when the lock cannot be taken, instead of
> skipping the restore, as I offered in my reply on v3 [1].
> - Use a helper around spi_nor_restore() again, as in v3, and the v3
> subject.
> - Say that the wait can last for a full chip erase; v4 understated it.
> - Drop the long code comment, and rewrite the commit message, with
> examples and a backport note.
> - Use the v3 form of Assisted-by.
> - Rebase on mainline.
>
> Why the lock is not just kept after the restore, which would also stop
> later operations: it hangs the reboot or kexec on boards whose SPI
> controller removes itself on shutdown (spi-fsl-dspi, spi-bcm2835,
> spi-ath79). spi_nor_remove() then runs after spi_nor_shutdown(), in the
> same task, and waits for the lock that spi_nor_shutdown() kept. With
> this patch, spi_nor_remove() gets the lock and skips the restore.
>
> Testing:
> - Built with W=1 for arm64, on mainline and, cherry-picked on top of
> f594a33f9721, on 6.6, 6.12, 6.18, 7.2 and 7.3. The backports to 5.10,
> 5.15 and 6.1 build cleanly too; I will send them when the stable team
> asks.
> - In QEMU (v7.3, ZynqMP GQSPI, n25q512a11 with broken-flash-reset, and
> the flash model patched to stay busy during an erase), with an
> application erasing and programming the flash during a kexec:
> - Without this patch, the flash ignores WREN, EX4B and WRDI, and stays
> in 4-byte mode.
> - With a draft that released the lock after the restore, the next
> erase went out with a 4-byte address. With a 10 s erase, it was
> still running when the secondary kernel probed the flash, and the
> probe failed.
> - With this patch, the flash obeys EX4B, nothing reaches it after the
> restore, and the secondary kernel finds the flash, with both a 3 s
> and a 10 s erase.
> - With the GQSPI driver changed to remove itself on shutdown, as
> spi-fsl-dspi does, a kexec with a draft that kept the lock hung, as
> spi_nor_remove() waited for it. With this patch, it completes, and the
> flash is restored once.
>
> v4: https://lore.kernel.org/r/20261004104311.2196527-1-itai.handler@gmail.com
> v3: https://lore.kernel.org/r/20260915113811.2429311-1-itai.handler@gmail.com
> [1] https://lore.kernel.org/r/CAFpOueRGN2TSNo+m3319qn00p-BYn8w7OQ6OPt4XTcVG63-uUA@mail.gmail.com
>
> drivers/mtd/spi-nor/core.c | 43 +++++++++++++++++++++++++++++++++++--
> include/linux/mtd/spi-nor.h | 2 ++
> 2 files changed, 43 insertions(+), 2 deletions(-)
>
> diff --git a/drivers/mtd/spi-nor/core.c b/drivers/mtd/spi-nor/core.c
> index 90524c58602e..3109f89b35f3 100644
> --- a/drivers/mtd/spi-nor/core.c
> +++ b/drivers/mtd/spi-nor/core.c
> @@ -1230,6 +1230,11 @@ int spi_nor_prep_and_lock(struct spi_nor *nor)
> ret = wait_event_killable(nor->rww.wait,
> spi_nor_rww_start_exclusive(nor));
>
> + if (!ret && nor->shutdown) {
> + spi_nor_unlock_and_unprep(nor);
> + return -ESHUTDOWN;
This will be propagated to userspace, correct? Not sure this is a
valid error code outside of sockets. Maybe EIO?
> + }
> +
> if (ret)
> spi_nor_unprep(nor);
>
> @@ -1290,6 +1295,8 @@ static void spi_nor_rww_end_pe(struct spi_nor *nor, loff_t start, size_t len)
> rww->ongoing_pe = false;
> }
>
> +static void spi_nor_unlock_and_unprep_pe(struct spi_nor *nor, loff_t start, size_t len);
> +
Please avoid forward declarations and move the functions.
> static int spi_nor_prep_and_lock_pe(struct spi_nor *nor, loff_t start, size_t len)
> {
> int ret;
> @@ -1304,6 +1311,11 @@ static int spi_nor_prep_and_lock_pe(struct spi_nor *nor, loff_t start, size_t le
> ret = wait_event_killable(nor->rww.wait,
> spi_nor_rww_start_pe(nor, start, len));
>
> + if (!ret && nor->shutdown) {
> + spi_nor_unlock_and_unprep_pe(nor, start, len);
> + return -ESHUTDOWN;
> + }
> +
> if (ret)
> spi_nor_unprep(nor);
>
> @@ -1366,6 +1378,8 @@ static void spi_nor_rww_end_rd(struct spi_nor *nor, loff_t start, size_t len)
> rww->ongoing_rd = false;
> }
>
> +static void spi_nor_unlock_and_unprep_rd(struct spi_nor *nor, loff_t start, size_t len);
> +
> static int spi_nor_prep_and_lock_rd(struct spi_nor *nor, loff_t start, size_t len)
> {
> int ret;
> @@ -1380,6 +1394,11 @@ static int spi_nor_prep_and_lock_rd(struct spi_nor *nor, loff_t start, size_t le
> ret = wait_event_killable(nor->rww.wait,
> spi_nor_rww_start_rd(nor, start, len));
>
> + if (!ret && nor->shutdown) {
> + spi_nor_unlock_and_unprep_rd(nor, start, len);
> + return -ESHUTDOWN;
> + }
> +
> if (ret)
> spi_nor_unprep(nor);
>
> @@ -3250,6 +3269,26 @@ static void spi_nor_restore(struct spi_nor *nor)
> spi_nor_soft_reset(nor);
> }
>
> +static void spi_nor_lock_and_restore(struct spi_nor *nor)
> +{
> + int ret;
> +
> + ret = spi_nor_prep_and_lock(nor);
> + if (ret == -ESHUTDOWN)
This is actually really hard to follow. It's tested for even before
it is set down below. Also probably wont work with an EIO return
code. See more below
> + return;
> + if (ret)
> + dev_warn(nor->dev,
> + "Failed to lock flash, restoring its power-on state anyway, err = %d\n",
> + ret);
> +
> + spi_nor_restore(nor);
> +
> + if (!ret) {
> + nor->shutdown = true;
Why don't you set the flag unconditionally?
> + spi_nor_unlock_and_unprep(nor);
> + }
> +}
> +
> static const struct flash_info *spi_nor_match_name(struct spi_nor *nor,
> const char *name)
> {
> @@ -3632,7 +3671,7 @@ static int spi_nor_remove(struct spi_mem *spimem)
> {
> struct spi_nor *nor = spi_mem_get_drvdata(spimem);
>
> - spi_nor_restore(nor);
> + spi_nor_lock_and_restore(nor);
So why don't you just keep spi_nor_restore() and just add the
locking there?
What about the following:
static void spi_nor_restore(struct spi_nor *nor)
{
struct spi_nor_flash_parameter *params = nor->params;
int lock_ret, ret;
lock_ret = spi_nor_prep_and_lock(nor);
/* already restored, e.g. remove() after shutdown(). */
if (nor->restored)
return;
if (lock_ret)
dev_warn(nor->dev, "...", lock_ret);
/* former body .. */
/* refuse any further operations */
nor->restored = true;
if (!lock_ret) {
spi_nor_unlock_and_unprep(nor);
}
}
>
> /* Clean up MTD stuff. */
> return mtd_device_unregister(&nor->mtd);
> @@ -3642,7 +3681,7 @@ static void spi_nor_shutdown(struct spi_mem *spimem)
> {
> struct spi_nor *nor = spi_mem_get_drvdata(spimem);
>
> - spi_nor_restore(nor);
> + spi_nor_lock_and_restore(nor);
> }
>
> /*
> diff --git a/include/linux/mtd/spi-nor.h b/include/linux/mtd/spi-nor.h
> index b3e3c6b10186..6f5d2e5c2118 100644
> --- a/include/linux/mtd/spi-nor.h
> +++ b/include/linux/mtd/spi-nor.h
> @@ -361,6 +361,7 @@ struct spi_nor_flash_parameter;
> * @read_opcode: the read opcode
> * @read_dummy: the dummy needed by the read operation
> * @program_opcode: the program opcode
> + * @shutdown: the flash was restored, refuse further operations
shutdown only covers some of its meaning, it might also just get
unbinded etc. So what about 'restored'?
-michael
> * @sst_write_second: used by the SST write operation
> * @read_proto: the SPI protocol for read operations
> * @write_proto: the SPI protocol for write operations
> @@ -402,6 +403,7 @@ struct spi_nor {
> enum spi_nor_protocol read_proto;
> enum spi_nor_protocol write_proto;
> enum spi_nor_protocol reg_proto;
> + bool shutdown;
> bool sst_write_second;
> struct sfdp *sfdp;
> struct dentry *debugfs_root;
>
> base-commit: c339f4010dea8b0d754f84ace70cd1b089878ef8
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 297 bytes --]
next prev parent reply other threads:[~2026-11-18 13:33 UTC|newest]
Thread overview: 4+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-10-29 21:01 [PATCH v5] mtd: spi-nor: take the flash lock around spi_nor_restore() Itai Handler
2026-11-10 8:27 ` Itai Handler
2026-11-18 13:33 ` Michael Walle [this message]
2026-11-18 14:23 ` Miquel Raynal
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=DMYDITU0H48Z.2LA5KF2TFNUY2@kernel.org \
--to=mwalle@kernel.org \
--cc=itai.handler@gmail.com \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-mtd@lists.infradead.org \
--cc=miquel.raynal@bootlin.com \
--cc=pratyush@kernel.org \
--cc=richard@nod.at \
--cc=stable@vger.kernel.org \
--cc=takahiro.kuwano@infineon.com \
--cc=tudor.ambarus@linaro.org \
--cc=vigneshr@ti.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox