I wanted to share what happened to me because I honestly thought my phone was gone for good. If someone finds this while desperately searching for a solution like I was, maybe it’ll help.
A few days ago my Nothing Phone (2) installed the latest OTA update. Right after the update the phone became incredibly slow. It was barely usable for a few minutes before it completely froze.
After forcing a reboot, it would only boot into **NOTHING CrashDump Mode (minidump)** with:
reset_reason: Unknown
I was convinced it was completely bricked.
The good news is… it eventually booted again without a factory reset, without flashing anything and without unlocking the bootloader.
For anyone wondering, my phone had:
- Locked bootloader
- Recovery still accessible
- Fastboot still accessible
- CrashDump every single time I rebooted
I used a Linux Mint PC to troubleshoot.
The first thing I did was install Google’s Android Platform Tools:
```bash
sudo apt update
sudo apt install android-sdk-platform-tools
```
Then I made sure everything was installed correctly:
```bash
adb version
fastboot –version
```
From there I booted into Fastboot and checked if the phone was still detected.
```bash
fastboot devices
```
Thankfully it was.
Then I started checking everything I could:
```bash
fastboot getvar product
fastboot getvar current-slot
fastboot getvar all
```
From the output I learned that:
- the bootloader was locked
- slot B was active
- slot A was marked as unbootable
I even tried switching to slot A:
```bash
fastboot –set-active=a
```
but got:
```
FAILED (remote: ‘Slot Change is not allowed in Lock State’)
```
which makes sense with a locked bootloader.
After that I booted into Recovery:
```bash
fastboot reboot recovery
```
At this point I made one decision:
**I was not going to factory reset the phone unless I had absolutely no other choice.**
Instead I started checking everything that looked safe.
I went through Recovery multiple times.
I opened the recovery logs.
I mounted the system partition.
I entered ADB sideload mode.
I rebooted back to Fastboot.
Then back into Recovery.
I repeated this process over and over while trying to understand what had actually broken.
When I entered **Apply update from ADB**, my computer detected the phone correctly.
```bash
adb devices
```
Output:
```
xxxxxxxx sideload
```
I also tried things like:
```bash
adb reboot recovery
adb shell
adb pull /tmp/recovery.log
```
Unfortunately I discovered that the stock Nothing Recovery only exposes ADB while sideload mode is active, so I couldn’t pull the recovery log directly.
Instead I opened:
```
/tmp/recovery.log
```
from Recovery itself and read through it manually.
The strange thing is that I never found any obvious errors like AVB verification failures, dm-verity corruption or userdata mount failures.
Most of the interesting messages were related to OTA snapshots, for example:
```
Cannot read /metadata/ota/snapshot-boot
Not booting from new slot. Will not mount snapshots.
```
which made me think the OTA update or the Virtual A/B Snapshot process had somehow been interrupted.
Recovery was still able to mount the partitions, so nothing looked completely destroyed.
Then something weird happened.
After spending almost an hour going back and forth between Fastboot, Recovery, Recovery Logs, Mount /system, ADB sideload and Reboot system…
the phone suddenly booted.
Just like that.
No flashing.
No factory reset.
No Nothing Flash Tool.
No unlocked bootloader.
Nothing.
I honestly have no idea what actually fixed it.
Maybe I got lucky.
Maybe Android finally finished something internally.
Maybe the OTA snapshot recovered by itself.
I really don’t know.
The very first thing I did after the phone booted was back up absolutely everything.
I’m not posting this because I found a magic fix.
I’m posting it because when I was searching online, almost every answer was “factory reset” or “flash the phone.”
If your phone is still able to access Fastboot and Recovery, don’t assume all hope is lost. It might be worth taking the time to investigate before wiping your data.
If anyone knows what actually happened here or has a technical explanation, I’d genuinely love to hear it.
