В ядре Linux устранена следующая уязвимость:
xprtrdma: отделить переработку запросов от завершения RPC
rl_kref раньше обслуживал две разные жизни в одном
refcount: он запускается, когда Ответ может разбудить свою задачу RPC, и это
закрывается, когда rpcrdma_req может вернуться в свой свободный пул.
путь маршала использовал ссылку на стороне отправки только тогда, когда это было необходимо SGE. DMA-unmap (sc_unmap_count > 0), что сделало отправку переносимой только
предварительно зарегистрированные буферы - исключение: обработчик ответа удален
rl_kref с 1 на 0 и освободил запрос, пока HCA еще мог
быть DMA-чтением из буфера отправки. Дайте rl_kref более узкую задачу.
Уровень RPC принимает одну ссылку
когда распределение слотов выдает запрос. rpcrdma_prepare_send_sges()
принимает ссылку на сторону отправки безоговорочно после подготовки WR
удается. xprt_rdma_free_slot() и xprt_rdma_bc_free_rqst() отбрасываются
ссылка на уровень RPC; rpcrdma_sendctx_unmap() удаляет
Ссылка на стороне отправки. Запрос возвращается в свой свободный пул только после
оба владельца подписали соглашение. Существующий вызов kref_init(&req->rl_kref)
rpcrdma_prepare_send_sges() удален.
Инициализация переходит в
пути распределения слотов (xprt_rdma_alloc_slot и
rpcrdma_bc_rqst_get), и обратный вызов Release повторно активирует rl_kref.
прежде чем запрос вернется в свободный пул. Повторная инициализация в маршале
path отбросит уже существующую ссылку на уровень RPC.
при входе. Далее следуют три инварианта:
- Любой rpcrdma_req, хранящийся в rpc_rqst, имеет rl_kref >= 1.
xprt_rdma_alloc_slot(), rpcrdma_bc_rqst_get() и
ветвь backlog-wake в xprt_rdma_alloc_slot() каждый kref_init
rl_kref перед публикацией запроса.
Без этого инварианта
задача RPC, которая прерывается между выделением слотов и маршалированием
(ошибка gss_refresh или сигнал во время call_connect, например
пример) будет управлять xprt_release() ->
xprt_rdma_free_slot() -> kref_put по счетчику ссылок
ноль, насыщая refcount_t и блокируя слот.
- Ссылка на стороне отправки берется только после подготовки WR.
удается. Ошибка сопоставления в rpcrdma_prepare_send_sges().
запускает rpcrdma_sendctx_cancel(), который DMA отменяет отображение sendctx
и очищает sc_req, не трогая rl_kref. sendctx
обход кольца в rpcrdma_sendctx_put_locked() и
rpcrdma_sendctxs_destroy() пропускает записи с помощью sc_req == NULL,
поэтому серия ошибок маршалирования -EIO не может сдерживать требования
rb_send_bufs.
- Обратный вызов Release повторно активирует rl_kref, чтобы следующий потребитель
входит с удовлетворенным инвариантом. Ответы теперь дополняют RPC напрямую. rpcrdma_reply_handler()
вызывает rpcrdma_complete_rqst() вместо kref_put на
не-LocalInv ветка.
Ветка LocalInv уже завершает
RPC из frwr_unmap_async() и не затрагивается. Поскольку ссылки на стороне отправки теперь могут пережить завершение RPC,
Разрыв соединения истощает записи sendctx, чьи несигнализированные
У Сэндса никогда не было более позднего сигнала о завершении выхода на ринг.
rpcrdma_sendctxs_destroy() обходит активный диапазон и запускается
rpcrdma_sendctx_unmap() для каждой записи с непустым sc_req
перед сбросом буферов запросов и перемещается вперед
rpcrdma_reqs_reset() в rpcrdma_xprt_disconnect(), поэтому требования
все еще находятся в состоянии предварительного сброса, когда ссылки на стороне отправки
выпущен. Слив создает опасность нарушения порядка в обратном канале.
путь.
С новым сроком службы выпустим запрос bc_prealloc из
rpcrdma_req_release() повторно добавляет его в bc_pa_list. Разъединение
в xprt_rdma_destroy() запускается после того, как xprt_destroy_backchannel()
bc_pa_list уже очищен, поэтому в противном случае опустошенные запросы
утечка. xprt_rdma_destroy() теперь запускает xprt_rdma_bc_destroy(xprt, 0)
второй раз после отключения, чтобы вернуть их.
Показать оригинальное описание (EN)
In the Linux kernel, the following vulnerability has been resolved: xprtrdma: Decouple req recycling from RPC completion rl_kref formerly served two distinct lifetimes through a single refcount: it gated when a Reply could wake its RPC task, and it gated when an rpcrdma_req could return to its free pool. The marshal path took the Send-side reference only when SGEs needed DMA-unmap (sc_unmap_count > 0), which made a Send carrying only pre-registered buffers an exception: the Reply handler dropped rl_kref from 1 to 0 and freed the req while the HCA might still be DMA-reading from its send buffer. Give rl_kref a narrower job. The RPC layer takes one reference when slot allocation hands a req out. rpcrdma_prepare_send_sges() takes a Send-side reference unconditionally after WR preparation succeeds. xprt_rdma_free_slot() and xprt_rdma_bc_free_rqst() drop the RPC-layer reference; rpcrdma_sendctx_unmap() drops the Send-side reference. The req returns to its free pool only after both owners have signed off. The existing kref_init(&req->rl_kref) call in rpcrdma_prepare_send_sges() is removed. Initialization moves to the slot-allocation paths (xprt_rdma_alloc_slot and rpcrdma_bc_rqst_get), and the release callback re-arms rl_kref before the req returns to a free pool. A re-init in the marshal path would discard the RPC-layer reference that already exists on entry. Three invariants follow: - Any rpcrdma_req held by an rpc_rqst has rl_kref >= 1. xprt_rdma_alloc_slot(), rpcrdma_bc_rqst_get(), and the backlog-wake branch in xprt_rdma_alloc_slot() each kref_init rl_kref before publishing the req. Without this invariant, an RPC task that aborts between slot allocation and marshal (gss_refresh failure or signal during call_connect, for example) would drive xprt_release() -> xprt_rdma_free_slot() -> kref_put against a refcount of zero, saturating refcount_t and stranding the slot. - The Send-side reference is taken only after WR prep succeeds. A mapping failure in rpcrdma_prepare_send_sges() runs rpcrdma_sendctx_cancel(), which DMA-unmaps the sendctx and clears sc_req without touching rl_kref. The sendctx ring walks in rpcrdma_sendctx_put_locked() and rpcrdma_sendctxs_destroy() skip entries with sc_req == NULL, so a burst of -EIO marshal failures cannot hold reqs off rb_send_bufs. - The release callback re-arms rl_kref so the next consumer enters with the invariant satisfied. Replies now complete the RPC directly. rpcrdma_reply_handler() calls rpcrdma_complete_rqst() in place of kref_put on the non-LocalInv branch. The LocalInv branch already completes the RPC from frwr_unmap_async() and is unaffected. Because Send-side references can now outlive RPC completion, connection teardown drains sendctx entries whose unsignaled Sends never had a later signaled completion to walk the ring. rpcrdma_sendctxs_destroy() walks the active range and runs rpcrdma_sendctx_unmap() on each entry with a non-NULL sc_req before the request buffers are reset, and is moved ahead of rpcrdma_reqs_reset() in rpcrdma_xprt_disconnect() so the reqs are still in their pre-reset state when the Send-side refs are released. The drain creates a teardown-ordering hazard on the backchannel path. With the new lifetime, releasing a bc_prealloc req from rpcrdma_req_release() re-adds it to bc_pa_list. The disconnect in xprt_rdma_destroy() runs after xprt_destroy_backchannel() has already emptied bc_pa_list, so the drained reqs would otherwise leak. xprt_rdma_destroy() now runs xprt_rdma_bc_destroy(xprt, 0) a second time after the disconnect to reclaim them.
Характеристики атаки
Последствия
Строка CVSS v3.1
Уязвимые продукты 6
| Конфигурация | От (включительно) | До (исключительно) |
|---|---|---|
|
Linux Linux_Kernel
cpe:2.3:o:linux:linux_kernel:*:*:*:*:*:*:*:*
|
5.3
|
6.1.178
|
|
Linux Linux_Kernel
cpe:2.3:o:linux:linux_kernel:*:*:*:*:*:*:*:*
|
5.3
|
6.6.145
|
|
Linux Linux_Kernel
cpe:2.3:o:linux:linux_kernel:*:*:*:*:*:*:*:*
|
5.3
|
6.12.97
|
|
Linux Linux_Kernel
cpe:2.3:o:linux:linux_kernel:*:*:*:*:*:*:*:*
|
5.3
|
6.18.40
|
|
Linux Linux_Kernel
cpe:2.3:o:linux:linux_kernel:*:*:*:*:*:*:*:*
|
5.3
|
7.1.5
|
|
Linux Linux_Kernel
cpe:2.3:o:linux:linux_kernel:*:*:*:*:*:*:*:*
|
5.3
|
7.2-rc1
|