Odebrany

CVE-2026-98069

opublikowano: 25.09.2026, 13:17

modyfikacja: 25.09.2026, 17:18

Ocena CVSS

n/a

Brak oceny

Oficjalne źródła

>_ Opis

Tłumaczenie automatyczne – może zawierać nieścisłości.

W jądrze Linuksa usunięto następującą lukę:

net/rds: zdobądź blokady Fastpath w rds_conn_shutdown()

rds_conn_shutdown() wycisza ścieżki transmisji i odbioru-uzupełniania poprzez
oczekiwanie na wyczyszczenie próbek RDS_IN_XMIT i RDS_RECV_REFILL i
następnie uruchamia zamknięcie transportu i funkcję rds_conn_path_reset(). Próbkowanie
czyste bity to nie to samo, co ich posiadanie: chwila po
Wait_event() zwraca, rds_send_xmit() może ponownie uzyskać RDS_IN_XMIT (lub
rds_ib_recv_refill() może ponownie uzyskać RDS_RECV_REFILL) i uruchomić
równocześnie z rozbiórką.

Nadawca ponownie sprawdza stan połączenia po przejęciu blokady,
ale to ponowne sprawdzenie to klasyczny wzorzec buforowania sklepu: zapisuje porzucenie
stanu i odczytuje bit, podczas gdy nadawca zapisuje bit i czyta
stan. nabyć_in_xmit() jest tylko operacją nabycia, i tak dalej
słabo uporządkowane architektury obie strony mogą przegapić wzajemne zapisy,
a następnie ścieżka transmisji przebiega, podczas gdy transport zeruje swoje pierścienie
(np. rds_ib_ring_init()) i rds_send_path_reset() przepisują
przesyłać stan pod nim.

Oracle UEK naprawił awarie tej samej klasy – koniec 14 lat
BUG_ON() w rds_ib_sub_signaled(), nieoczekiwane kody operacji i NULL
dereferencje w rds_ib_send_cqe_handler() podczas testowania przełączania awaryjnego -
zamiast tego *nabywanie* ścieżki rozrywania powoduje zablokowanie bitu szybkiej ścieżki
ich przetestowania („rds: Upewnij się, że ścieżka transmisji i połączenie
rozbieranie nie przebiega jednocześnie”). Własność jednego słowa jest
decyduje atomowość RMW, więc nie jest potrzebne porządkowanie zmiennych między zmiennymi.

Zrób to samo tutaj: weź oba zamki przed wezwaniem transportu
zamknięcie, przytrzymaj je w funkcji rds_conn_path_reset() i zwolnij
wyraźnie z późniejszym przebudzeniem. Oba są wydawane z
clear_bit_unlock(), tak że ponowna inicjalizacja pierścienia wykonana przez
zamknięcie transportu i przepisanie stanu transmisji przez
rds_send_path_reset() są uporządkowane, zanim którykolwiek bit zostanie wyczyszczony
następna funkcja nabyć_in_xmit() lub nabyć_refill().

Użytkownicy Fastpath tych bitów - rds_send_xmit() i
rds_ib_recv_refill() - działają w stylu trylock i wycofują się podczas porzucania
jest właścicielem blokad, więc nie jest dla nich wprowadzana żadna nowa zależność od blokad.
rds_tcp_reset_callbacks() jest inna: od poprzedniej łatki
przejmuje również RDS_IN_XMIT i blokuje to, więc teraz czeka
obejmuje rozbiórkę, a nie co najwyżej jedną partię wysłania. Ten kelner
działa z rds_tcp_accept_one() w jednowątkowej kolejce roboczej krdsd
i trzyma rds_tcp_accept_lock i t_conn_path_lock podczas oczekiwania, więc
pojedynkowy SYN zaakceptowany, podczas gdy jego ścieżka jest burzona w parkach
zaakceptować przetwarzanie na czas porzucenia - dla protokołu TCP ograniczonego
przez (do 5 s) pętlę drenażową w rds_tcp_conn_path_shutdown(). IB
odpływ ścieżki w rds_ib_conn_path_shutdown() nie ma okrągłego wieczka, ale nie
blokujący kelner albo: rds_tcp_reset_callbacks() jest jedyną blokadą
nabywca tych bitów i czeka tylko na własnej ścieżce TCP, oraz
szybkie ścieżki są typu trylock-and-back-off w obu transportach, więc długi IB
drenaż wydłuża jedynie spokój tej ścieżki. The
okno jest wąskie: sprawdzenie stanu po stronie akceptacji musi przejść przed
porzucenie przenosi ścieżkę do RDS_CONN_DISCONNECTING.

Ponieważ krdsd jest pojedynczą globalną kolejką roboczą, wszystko inne znajduje się w kolejce
tam - zaakceptuj przetwarzanie dla innych połączeń i sieci
przestrzenie nazw i kolejka Flush_workqueue(rds_wq) w rds_tcp_listen_stop()
podczas rozłączania przestrzeni nazw — czeka za zaparkowanym pracownikiem akceptującym
ten czas. Nie może się zablokować, chociaż oczekiwania wskazują na każde z nich
inne: rozrywanie blokuje się do momentu zwolnienia uchwytu bitu, oraz
posiadaczem może być pracownik akceptowany przez krdsd. Posiadacz kończy
bez potrzeby posiadania czegokolwiek, co posiada porzucenie: synchronizacja zostaje anulowana
rds_tcp_reset_callbacks() wystawia cele cp_send_w i cp_recv_w na
uporządkowana ścieżka cp_wq, której jedyne miejsce wykonania jest zajęte
zablokowany sam cp_down_w, więc co najwyżej oczekują i anulują
bez opróżniania - teraz poleganie na zamówieniu cp_wq
zaznaczone obok tych anulowań (na
---obcięty---

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

net/rds: acquire the fastpath locks in rds_conn_shutdown()

rds_conn_shutdown() quiesces the transmit and receive-refill paths by
waiting for RDS_IN_XMIT and RDS_RECV_REFILL to be sampled clear, and
then runs the transport shutdown and rds_conn_path_reset(). Sampling
the bits clear is not the same as owning them: the moment after the
wait_event() returns, rds_send_xmit() can re-acquire RDS_IN_XMIT (or
rds_ib_recv_refill() can re-acquire RDS_RECV_REFILL) and run
concurrently with the teardown.

The sender does recheck the connection state after taking the lock,
but that recheck is a classic store-buffering pattern: teardown writes
the state and reads the bit while the sender writes the bit and reads
the state. acquire_in_xmit() is only an acquire operation, so on
weakly ordered architectures both sides can miss each other's write,
and the transmit path then runs while the transport zeroes its rings
(e.g. rds_ib_ring_init()) and rds_send_path_reset() rewrites the
transmit state under it.

Oracle UEK fixed the same class of crashes - a 14-year tail of
BUG_ON()s in rds_ib_sub_signaled(), unexpected op-codes and NULL
dereferences in rds_ib_send_cqe_handler() during failover testing -
by making the teardown path *acquire* the fastpath bit locks instead
of testing them ("rds: Make sure transmit path and connection
tear-down does not run concurrently"). Ownership of a single word is
decided by RMW atomicity, so no cross-variable ordering is needed.

Do the same here: take both locks before calling the transport
shutdown, hold them across rds_conn_path_reset(), and release them
explicitly with a wake-up afterwards. Both are released with
clear_bit_unlock(), so that the ring re-initialization done by the
transport shutdown and the transmit state rewritten by
rds_send_path_reset() are ordered before either bit is seen clear by
the next acquire_in_xmit() or acquire_refill().

The fastpath users of these bits - rds_send_xmit() and
rds_ib_recv_refill() - are trylock style and back off while teardown
owns the locks, so no new lock dependency is introduced for them.
rds_tcp_reset_callbacks() is different: since the previous patch it
acquires RDS_IN_XMIT as well, and it blocks doing so, so its wait now
spans the teardown instead of at most one send batch. That waiter
runs from rds_tcp_accept_one() on the single-threaded krdsd workqueue
and holds rds_tcp_accept_lock and t_conn_path_lock while it waits, so
a duelling SYN accepted while its path is being torn down parks
accept processing for the duration of the teardown - for TCP bounded
by the (up to 5 s) drain loop in rds_tcp_conn_path_shutdown(). An IB
path's drain in rds_ib_conn_path_shutdown() has no round cap, but no
blocking waiter either: rds_tcp_reset_callbacks() is the only blocking
acquirer of these bits and waits only on its own TCP path, and the
fastpaths are trylock-and-back-off on both transports, so a long IB
drain lengthens only that path's own quiesce. The
window is narrow: the accept-side state check has to pass before the
teardown moves the path to RDS_CONN_DISCONNECTING.

Because krdsd is a single global workqueue, everything else queued
there - accept processing for other connections and network
namespaces, and the flush_workqueue(rds_wq) in rds_tcp_listen_stop()
during namespace teardown - waits behind the parked accept worker for
that time. It cannot deadlock, although the waits do point at each
other: the teardown blocks until the bit's holder releases it, and
the holder may be that krdsd accept worker. The holder finishes
without needing anything the teardown owns: the sync cancels
rds_tcp_reset_callbacks() issues target cp_send_w and cp_recv_w on
the path's ordered cp_wq, whose only execution slot is occupied by
the blocked cp_down_w itself, so they are pending at most and cancel
without flushing - a reliance on cp_wq being ordered that is now
noted next to those cancels (on
---truncated---

>_ Referencje

Dane podatności pochodzą z oficjalnych źródeł (CVE® List / NVD). Opisy po polsku są tłumaczone automatycznie i mogą zawierać nieścisłości – na stronie rekordu można wyświetlić wersję angielską.

This product uses the NVD API but is not endorsed or certified by the NVD.

CVE Usage: MITRE hereby grants you a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, sublicense, and distribute Common Vulnerabilities and Exposures (CVE®). Any copy you make for such purposes is authorized provided that you reproduce MITRE's copyright designation and this license in any such copy. ALL DOCUMENTS AND THE INFORMATION CONTAINED THEREIN PROVIDED BY MITRE ARE PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND.

NVD Terms of Use / CVE® Terms of Use / nvd.nist.gov / cve.org

<< baza_cve