Is there any way that this could be exploited to cause a nullptr deref? I don't think that being able to fork at gensis block + 1 is possible... However, just want to point it out.

This is really confusing to read. Suggest:

CBlockIndex const *pindexExtraPow = pindexTip; 
uint32 blocksForked = pindexTip->nHeight - pindexFork->nHeight;
// Limit the penality for depth 2 and 3 to a block worth of
// work to ensure we don't fork accidentaly.
switch (blocksForked) {
    case 3:
        pindexExtraPow = pindexExtraPow->pprev;
        // FALLTHROUGH
    case 2:
        pindexExtraPow = pindexExtraPow->pprev;
}
arith_uint256 extraWork = pindexExtraPow->nChainWork - pindexFork->nChainWork;

I know you didn't write this, but wuuuut...

Shouldn't this block just be this?

nBlockReverseSequenceId = std::max(std::numeric_limits<int32_t>::min(), nBlockReverseSequenceId-1);

If I'm understanding this correctly, this means the reorg is more than one block? If so can we define "deep reorg" in the comment to clarify it.

// If this is a deep reorg(i.e. more than one block), preemptively mark the chain as parked. If it has

I think we should also assert that this is not true during the loop above.

The comment in the code says twice as much pow

Am I misreading the test in that this reorgs when you have over the same amount of work + 1 more block?

Might as well protect against it.

Should be "greater than 2x pow"

So why does this pass?

I wonder if this could also be an issue with a node running the -pruning option ?

I missed this portion. Can we add a comment here.

1. Add 1x total PoW worth of blocks

How is pindexTip supposed to have a fork point witht he other chain without any predecessor ?

Absolutely not.

We check the chain is parked.

Because 2x the PoW, when the fork is n block deep, means you got to produce n extra blocks.

Good point.

No, you check that node.getbestblockhash is parked on parking_node

You don't assert that parking_node.getbestblockhash() != node.getbestblockhash(). I am presuming though that getbestblockhash() should always be the active chain tip?

There is a behavior change here for getbestblockhash() that is not being tested. It previously returned the most PoW tip as an invariant. Now it returns the non-parked best PoW chain. That's only implied by the fat that on line 160 you have the assertion that parking_node.getbestblockhash() == node.getbestblockhash()

There is no assertion that this is NOT true anywhere else.

I would strongly encourage an:

assert(parking_node.getbestblockhash() != node.getbestblockhash()

added on line 157