nvme-tcp: Validate the queue state under the queue lock in the address attribute
PATCH 1/1 nvme-tcp: Validate the queue state under the queue lock in the address attribute
Reading the "address" sysfs attribute calls kernel_getsockname() on the admin queue socket, which can race with the queue teardown during connection error recovery: a reader can observe NVME_TCP_Q_LIVE set, then block on the queue lock while nvme_tcp_free_queue() releases the socket and clears queue->sock without holding the lock. Once the reader acquires the lock it dereferences the NULL socket pointer.
Commit 76d54bf20cdc ("nvme-tcp: don't access released socket during error recovery") had the queue liveness check inside the lock. Commit 782373ba2766 ("nvme: tcp: avoid race between queue_lock lock and destroy") moved it back out because the lock itself is destroyed in nvme_tcp_free_queue(), so a reader arriving late trips mutex_destroy().
Check the queue liveness inside the queue lock, and clear queue->sock under the same lock. The teardown clears NVME_TCP_Q_LIVE under the lock well before the socket is released, so a reader either sees the bit cleared or a socket that cannot be released while it holds the lock. To also close the lock lifetime race, the queue locks are now owned by the controller: they are initialized with the queue array and only destroyed when the controller is freed, which cannot happen while a sysfs attribute read is still in progress.
--- drivers/nvme/host/tcp.c | 43 ++++++++++++++++++++++++++++------------- 1 file changed, 30 insertions(+), 13 deletions(-)
drivers/nvme/host/tcp.c +30 -13
@@ -1514,14 +1514,21 @@ static void nvme_tcp_free_queue(struct nvme_ctrl *nctrl, int qid)* nvme_reset_ctrl_work(), queue teardown is immediately followed by * re-allocation. fput() defers socket cleanup to delayed_fput_work * in workqueue context, which can race with new queue setup. +* +* Clear queue->sock under the queue lock so that a sysfs reader in +* nvme_tcp_get_address() either observes the NVME_TCP_Q_LIVE bit +* cleared or a still valid socket. The queue lock itself is owned +* by the controller and only destroyed when the controller is +* freed, so readers blocked on it cannot race its teardown. */ +mutex_lock (&queue->queue_lock);__fput_sync (queue->sock->file); queue->sock =NULL ; +mutex_unlock (&queue->queue_lock);memalloc_noio_restore (noio_flag);kfree (queue->pdu);mutex_destroy (&queue->send_mutex); -mutex_destroy (&queue->queue_lock);mutex_destroy (&queue->pf_cache_lock); }
@@ -1839,7 +1846,6 @@ static int nvme_tcp_alloc_queue(struct nvme_ctrl *nctrl, int qid,int ret, rcv_pdu_size;struct file *sock_file; -mutex_init (&queue->queue_lock); queue->ctrl = ctrl;init_llist_head (&queue->req_list);INIT_LIST_HEAD (&queue->send_list);
@@ -1977,7 +1983,6 @@ static int nvme_tcp_alloc_queue(struct nvme_ctrl *nctrl, int qid, queue->sock =NULL ; err_destroy_mutex:mutex_destroy (&queue->send_mutex); -mutex_destroy (&queue->queue_lock);mutex_destroy (&queue->pf_cache_lock);return ret; }
@@ -2627,6 +2632,7 @@ static void nvme_tcp_stop_ctrl(struct nvme_ctrl *ctrl)static void nvme_tcp_free_ctrl (struct nvme_ctrl *nctrl) {struct nvme_tcp_ctrl *ctrl =to_tcp_ctrl (nctrl); +int i;if (list_empty_careful (&ctrl->list)) goto free_ctrl;
@@ -2637,6 +2643,8 @@ static void nvme_tcp_free_ctrl(struct nvme_ctrl *nctrl)nvmf_free_options (nctrl->opts); free_ctrl: +for (i =0 ; i < ctrl->ctrl.queue_count; i++) +mutex_destroy (&ctrl->queues[i].queue_lock);kfree (ctrl->queues);kfree (ctrl); }
@@ -2889,17 +2897,18 @@ static int nvme_tcp_get_address(struct nvme_ctrl *ctrl, char *buf, int size) len =nvmf_get_address (ctrl, buf, size); -if (!test_bit (NVME_TCP_Q_LIVE , &queue->flags)) -return len; -mutex_lock (&queue->queue_lock); - ret =kernel_getsockname (queue->sock, (struct sockaddr *)&src_addr); -if (ret >0 ) { -if (len >0 ) - len--;/* strip trailing newline */ - len +=scnprintf (buf + len, size - len,"%ssrc_addr=%pISc\n" , - (len) ?"," :"" , &src_addr); +if (test_bit (NVME_TCP_Q_LIVE , &queue->flags)) { + ret =kernel_getsockname (queue->sock, + (struct sockaddr *)&src_addr); +if (ret >0 ) { +if (len >0 ) + len--;/* strip trailing newline */ + len +=scnprintf (buf + len, size - len, +"%ssrc_addr=%pISc\n" , + (len) ?"," :"" , &src_addr); + } }mutex_unlock (&queue->queue_lock);
@@ -2965,7 +2974,7 @@ static struct nvme_tcp_ctrl *nvme_tcp_alloc_ctrl(struct device *dev, struct nvmf_ctrl_options *opts) {struct nvme_tcp_ctrl *ctrl; -int ret; +int ret, i; ctrl =kzalloc_obj (*ctrl);if (!ctrl)
@@ -3035,6 +3044,14 @@ static struct nvme_tcp_ctrl *nvme_tcp_alloc_ctrl(struct device *dev, goto out_free_ctrl; } +/* +* The queue locks are owned by the controller, not the queues: +* they outlive the per-queue connect/disconnect cycles so that +* sysfs readers can never race their destruction. +*/ +for (i =0 ; i < ctrl->ctrl.queue_count; i++) +mutex_init (&ctrl->queues[i].queue_lock); + ret =nvme_init_ctrl (&ctrl->ctrl, dev, &nvme_tcp_ctrl_ops,0 );if (ret) goto out_kfree_queues;
Signature · 1 line
2.43.7
Quoted 30 lines · Guixin Liu
Reading the "address" sysfs attribute calls
kernel_getsockname()on the admin queue socket, which can race with the queue teardown during connection error recovery: a reader can observeNVME_TCP_Q_LIVEset, then block on the queue lock whilenvme_tcp_free_queue()releases the socket and clearsqueue->sockwithout holding the lock. Once the reader acquires the lock it dereferences the NULL socket pointer.Commit
76d54bf20cdc("nvme-tcp: don't access released socket during error recovery") had the queue liveness check inside the lock. Commit782373ba2766("nvme: tcp: avoid race betweenqueue_locklock and destroy") moved it back out because the lock itself is destroyed innvme_tcp_free_queue(), so a reader arriving late tripsmutex_destroy().Check the queue liveness inside the queue lock, and clear
queue->sockunder the same lock. The teardown clearsNVME_TCP_Q_LIVEunder the lock well before the socket is released, so a reader either sees the bit cleared or a socket that cannot be released while it holds the lock. To also close the lock lifetime race, the queue locks are now owned by the controller: they are initialized with the queue array and only destroyed when the controller is freed, which cannot happen while a sysfs attribute read is still in progress.Fixes 782373ba2766 ("nvme: tcp: avoid race between queue_lock lock and destroy")Signed-off-by Guixin Liu<[email protected]>--- drivers/nvme/host/tcp.c | 43 ++++++++++++++++++++++++++++------------- 1 file changed, 30 insertions(+), 13 deletions(-)
[...]
Quoted 9 lines
drivers/nvme/host/tcp.c +1
-0@@ -2627,6 +2632,7 @@ static void nvme_tcp_stop_ctrl(struct nvme_ctrl *ctrl)static void nvme_tcp_free_ctrl (struct nvme_ctrl *nctrl) {struct nvme_tcp_ctrl *ctrl =to_tcp_ctrl (nctrl); +int i;if (list_empty_careful (&ctrl->list)) goto free_ctrl;
drivers/nvme/host/tcp.c static void nvme_tcp_free_ctrl(struct nvme_ctrl *nctrl) · line 2647
Quoted 5 lines
drivers/nvme/host/tcp.c +2
-0@@ -2637,6 +2643,8 @@ static void nvme_tcp_free_ctrl(struct nvme_ctrl *nctrl)nvmf_free_options (nctrl->opts); free_ctrl: +for (i =0 ; i < ctrl->ctrl.queue_count; i++) +mutex_destroy (&ctrl->queues[i].queue_lock);
What if in case ctrl->ctrl.queue_count changes during the lifetime of connection? I think in case num of queues changes during reconnect then ctrl.queue_count would not represent the initial value of the num of queues.
Thanks,
--Nilay
Quoted 43 lines · Nilay Shroff
Quoted 30 lines · Guixin Liu
Reading the "address" sysfs attribute calls
kernel_getsockname()on the admin queue socket, which can race with the queue teardown during connection error recovery: a reader can observeNVME_TCP_Q_LIVEset, then block on the queue lock whilenvme_tcp_free_queue()releases the socket and clearsqueue->sockwithout holding the lock. Once the reader acquires the lock it dereferences the NULL socket pointer.Commit
76d54bf20cdc("nvme-tcp: don't access released socket during error recovery") had the queue liveness check inside the lock. Commit782373ba2766("nvme: tcp: avoid race betweenqueue_locklock and destroy") moved it back out because the lock itself is destroyed innvme_tcp_free_queue(), so a reader arriving late tripsmutex_destroy().Check the queue liveness inside the queue lock, and clear
queue->sockunder the same lock. The teardown clearsNVME_TCP_Q_LIVEunder the lock well before the socket is released, so a reader either sees the bit cleared or a socket that cannot be released while it holds the lock. To also close the lock lifetime race, the queue locks are now owned by the controller: they are initialized with the queue array and only destroyed when the controller is freed, which cannot happen while a sysfs attribute read is still in progress.Fixes 782373ba2766 ("nvme: tcp: avoid race between queue_lock lock and destroy")Signed-off-by Guixin Liu<[email protected]>---
drivers/nvme/host/tcp.c| 43 ++++++++++++++++++++++++++++-------------1 file changed, 30 insertions(+), 13 deletions(-)[...]
Quoted 9 lines
drivers/nvme/host/tcp.c +1
-0@@ -2627,6 +2632,7 @@ static void nvme_tcp_stop_ctrl(struct nvme_ctrl *ctrl) static void nvme_tcp_free_ctrl(struct nvme_ctrl *nctrl) { struct nvme_tcp_ctrl *ctrl = to_tcp_ctrl(nctrl); + int i; if (list_empty_careful(&ctrl->list)) goto free_ctrl;@@ -2637,6 +2643,8 @@ static void nvme_tcp_free_ctrl(struct nvme_ctrl *nctrl) nvmf_free_options(nctrl->opts);
Quoted 8 lines
Quoted 3 lines
free_ctrl:
+ for (i = 0; i <ctrl->ctrl.queue_count; i++) +mutex_destroy(&ctrl->queues[i].queue_lock);What if in case
ctrl->ctrl.queue_countchanges during the lifetime of connection? I think in case num of queues changes during reconnect then ctrl.queue_count would not represent the initial value of the num of queues.
Good catch, but this is not a bug, the queue_count will only be turn down, so will not destroy an uninitialized mutex, and undestroyed mutex doesn't cause any memory leak.
But, any way, I will send a v2 to fix this, use nctrl->opts->nr_io_queues + nctrl->opts->nr_write_queues + nctrl->opts->nr_poll_queues + 1 to find the initial queue_count to destroy all initialized mutex.
Best Regards,
Guixin Liu
Quoted 3 lines
Thanks,
--Nilay