Re: [PATCH net-next v2 0/9] dpll: do not serialize driver callbacks under global dpll_lock

From: Vadim Fedorenko

Date: Fri Nov 20 2026 - 15:00:39 EST


On 20/11/2026 07:39, Ivan Vecera wrote:
On 11/19/26 22:38, Jakub Kicinski wrote:
Well, I'm not convinced. The relations between objects in DPLL are
already quite hard to follow, and objects from one driver routinely
"plug" into objects from another. The explanation of the locking
rules in patch 9 does not look clean or clear. The driver facing
API needs to be much more "dummy-proof".

Fair enough. The complicated part of the rules comes exactly from
that: a pin registered by another driver, like the zl3073x pins that
ice registers with its TXC DPLL or uses as parents of its RCLK pins.
A message about such a pin runs callbacks of both drivers. I have
prototypes of the first four ways below to lock this, each with KUnit
tests, and would like your opinion before going further.

In all of them a domain is the set of objects created with the same
module and clock_id, dpll_lock becomes an rwsem for the topology and
lifetime, and a mutex per domain serializes the callbacks.

A) Pin's domain (this series)

   Callbacks of a pin run under the domain of the pin, whichever
   driver registered them.

   Pros:
   * one domain lock at a time, so no lock order
   * a request or a message about a pin is atomic
   Cons:
   * the callbacks of a foreign pin are serialized with the driver
     that created the pin, not with the other callbacks of the driver
     that registered it, so that driver has to protect the shared
     state itself, and lockdep cannot check it
   * restrictions for measured_freq_get, reference sync pairs and the
     private data of a parent pin, which patch 9 has to explain

B) Registrant's domain, deferred notifications

   Each callback runs under the domain of the driver that registered
   it. A message about a pin takes the domain locks one after another,
   and notifications from callbacks are queued and sent once the
   domain lock is dropped.

   Pros:
   * callbacks registered by one driver instance are always
     serialized with each other
   * one domain lock at a time, so no lock order
   Cons:
   * a request or a message about a pin registered across domains is
     not atomic
   * the most complex core: a notification queue per domain, a lock
     per object to keep its messages in order, and pin setters split
     into validation and apply parts

C) Registrant's domain nested under the pin's domain

   Pros:
   * callbacks registered by one driver instance are serialized with
     each other and with the driver that created the pin
   * a request or a message about a pin is atomic
   Cons:
   * the lock order comes from the topology, so a pin of A registered
     with a DPLL of B together with a pin of B registered with a DPLL
     of A deadlocks, and lockdep sees it only with a lockdep class per
     domain
   * a stuck foreign registrant stops the domain of the pin

D) Merged domains (your suggestion)

   Registering a pin with a DPLL or a parent pin of another domain
   merges both domains. They are not split again.

   Pros:
   * the rules for drivers stay as they are with the global lock
     today, and lockdep checks them; the only new one is that state
     shared between chips not connected by a pin needs a driver lock
   * a request or a message is atomic
   Cons:
   * only hardware not connected by pins runs in parallel; on the
     GNR-D system the zl3073x and all ice PFs end up in one domain
   * a callback that waits for the hardware, like the planned resync
     for up to 1 s, or for firmware still stalls all DPLL devices in
     the merged domain

E) Global dpll_lock, slow callbacks asynchronous

   Pros:
   * no change in the core
   Cons:
   * the resync problems from my previous mail, and a callback that
     waits for firmware still stalls all DPLL devices in the system

I wrote before that stretching the domains would not improve
anything on that system. That holds for the ToD stall I measured,
but the zl3073x does not need to hold its channel lock across the
edge waits. Without that, the remaining waits are the planned resync
and output state callbacks, and with D they stall only the devices
wired to that chip, which depend on it anyway.

So I lean towards D, as it gives drivers nothing new to get right.
Would that address your concern, or do you see a better way?

It would be good to hear from the other DPLL maintainers as well.
Jiri, Vadim, Arkadiusz, what do you think?

I totally agree with Jakub. Current implementation of DPLL subsystem is
over complicated, and all these complications came just to completely
model what was designed for Intel NICs, basically ice driver. But now we
are again back to the discussion how to complicate things further just
to fit what was implemented in the new generation of the same hardware.

Maybe it's time to step back and think if we really need all this, or
find simpler way to express/model things?