In the Linux kernel, the following vulnerability has been resolved:

rust_binder: call set_notification_done() without proc lock

Consider the following sequence of events on a death listener:
1. The remote process dies and sends a BR_DEAD_BINDER message.
2. The local process invokes the BC_CLEAR_DEATH_NOTIFICATION command.
3. The local process then invokes the BC_DEAD_BINDER_DONE.
Then, the kernel will reply to the BC_DEAD_BINDER_DONE command with a
BR_CLEAR_DEATH_NOTIFICATION_DONE reply using push_work_if_looper().

However, this can result in a deadlock if the current thread is not a
looper. This is because dead_binder_done() still holds the proc lock
during set_notification_done(), which called push_work_if_looper().
Normally, push_work_if_looper() takes the thread lock, which is fine to
take under the proc lock. But if the current thread is not a looper,
then it falls back to delivering the reply to the process work queue,
which involves taking the proc lock. Since the proc lock is already
held, this is a deadlock.

Fix this by releasing the proc lock during set_notification_done(). It
was not intentional that it was held during that function to begin with.

I don't think this ever happens in Android because BC_DEAD_BINDER_DONE
is only invoked in response to BR_DEAD_BINDER messages, and the kernel
always delivers BR_DEAD_BINDER to a looper. So there's no scenario where
Android userspace will call BC_DEAD_BINDER_DONE on a non-looper thread.

En el kernel de Linux, la siguiente vulnerabilidad ha sido resuelta:

rust_binder: llamar a set_notification_done() sin el bloqueo de proc

Considere la siguiente secuencia de eventos en un oyente de muerte:
1. El proceso remoto muere y envía un mensaje BR_DEAD_BINDER.
2. El proceso local invoca el comando BC_CLEAR_DEATH_NOTIFICATION.
3. El proceso local luego invoca el BC_DEAD_BINDER_DONE.
Entonces, el kernel responderá al comando BC_DEAD_BINDER_DONE con una
respuesta BR_CLEAR_DEATH_NOTIFICATION_DONE usando push_work_if_looper().

Sin embargo, esto puede resultar en un interbloqueo si el hilo actual no es un
looper. Esto se debe a que dead_binder_done() aún mantiene el bloqueo de proc
durante set_notification_done(), que llamó a push_work_if_looper().
Normalmente, push_work_if_looper() toma el bloqueo de hilo, lo cual está bien tomar
bajo el bloqueo de proc. Pero si el hilo actual no es un looper,
entonces recurre a entregar la respuesta a la cola de trabajo del proceso,
lo que implica tomar el bloqueo de proc. Dado que el bloqueo de proc ya está
retenido, esto es un interbloqueo.

Solucione esto liberando el bloqueo de proc durante set_notification_done(). No
fue intencional que se mantuviera durante esa función para empezar.

No creo que esto ocurra nunca en Android porque BC_DEAD_BINDER_DONE
solo se invoca en respuesta a mensajes BR_DEAD_BINDER, y el kernel
siempre entrega BR_DEAD_BINDER a un looper. Así que no hay ningún escenario donde
el espacio de usuario de Android llame a BC_DEAD_BINDER_DONE en un hilo que no sea un looper.