github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-06-05 04:56:13 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

smb: server: manage recv credits by counting posted recv_io and granted credits

Browse Source 
(At least for me) the logic maintaining the count of posted
recv_io messages and the count of granted credits is much
easier to understand.

From there we can easily calculate the number of new_credits we'll
grant to the peer in outgoing send_io messages.

This will simplify the move to common logic that can be
shared between client and server in the following patches.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
Acked-by: Namjae Jeon <linkinjeon@kernel.org>
Signed-off-by: Steve French <stfrench@microsoft.com>
This commit is contained in:
Stefan Metzmacher 2025-08-14 16:05:47 +02:00 committed by Steve French
parent 113ed9d56f
commit 89b021a726
1 changed files with 21 additions and 32 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

53
fs/smb/server/transport_rdma.c
View File

@ -92,13 +92,10 @@ struct smb_direct_transport {
struct smbdirect_socket socket; struct smbdirect_socket socket;
spinlock_t receive_credit_lock; atomic_t recv_credits;
int recv_credits;
u16 recv_credit_target; u16 recv_credit_target;
spinlock_t lock_new_recv_credits; atomic_t recv_posted;
int new_recv_credits;
struct work_struct post_recv_credits_work; struct work_struct post_recv_credits_work;
struct work_struct send_immediate_work; struct work_struct send_immediate_work;
@ -309,9 +306,8 @@ static struct smb_direct_transport *alloc_transport(struct rdma_cm_id *cm_id)
sc->ib.dev = sc->rdma.cm_id->device; sc->ib.dev = sc->rdma.cm_id->device;
spin_lock_init(&t->receive_credit_lock); atomic_set(&t->recv_posted, 0);
atomic_set(&t->recv_credits, 0);
spin_lock_init(&t->lock_new_recv_credits);
INIT_WORK(&t->post_recv_credits_work, INIT_WORK(&t->post_recv_credits_work,
smb_direct_post_recv_credits); smb_direct_post_recv_credits);
@ -552,9 +548,8 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
sc->recv_io.reassembly.full_packet_received = true; sc->recv_io.reassembly.full_packet_received = true;
} }
spin_lock(&t->receive_credit_lock); atomic_dec(&t->recv_posted);
t->recv_credits -= 1; atomic_dec(&t->recv_credits);
spin_unlock(&t->receive_credit_lock);
old_recv_credit_target = t->recv_credit_target; old_recv_credit_target = t->recv_credit_target;
t->recv_credit_target = t->recv_credit_target =
@ -758,14 +753,10 @@ static void smb_direct_post_recv_credits(struct work_struct *work)
struct smb_direct_transport *t = container_of(work, struct smb_direct_transport *t = container_of(work,
struct smb_direct_transport, post_recv_credits_work); struct smb_direct_transport, post_recv_credits_work);
struct smbdirect_recv_io *recvmsg; struct smbdirect_recv_io *recvmsg;
int receive_credits, credits = 0; int credits = 0;
int ret; int ret;
spin_lock(&t->receive_credit_lock); if (atomic_read(&t->recv_credits) < t->recv_credit_target) {
receive_credits = t->recv_credits;
spin_unlock(&t->receive_credit_lock);
if (receive_credits < t->recv_credit_target) {
while (true) { while (true) {
recvmsg = get_free_recvmsg(t); recvmsg = get_free_recvmsg(t);
if (!recvmsg) if (!recvmsg)
@ -780,17 +771,11 @@ static void smb_direct_post_recv_credits(struct work_struct *work)
break; break;
} }
credits++; credits++;
atomic_inc(&t->recv_posted);
} }
} }
spin_lock(&t->receive_credit_lock);
t->recv_credits += credits;
spin_unlock(&t->receive_credit_lock);
spin_lock(&t->lock_new_recv_credits);
t->new_recv_credits += credits;
spin_unlock(&t->lock_new_recv_credits);
if (credits) if (credits)
queue_work(smb_direct_wq, &t->send_immediate_work); queue_work(smb_direct_wq, &t->send_immediate_work);
} }
@ -837,11 +822,18 @@ static int manage_credits_prior_sending(struct smb_direct_transport *t)
{ {
int new_credits; int new_credits;
spin_lock(&t->lock_new_recv_credits); if (atomic_read(&t->recv_credits) >= t->recv_credit_target)
new_credits = t->new_recv_credits; return 0;
t->new_recv_credits = 0;
spin_unlock(&t->lock_new_recv_credits);
new_credits = atomic_read(&t->recv_posted);
if (new_credits == 0)
return 0;
new_credits -= atomic_read(&t->recv_credits);
if (new_credits <= 0)
return 0;
atomic_add(new_credits, &t->recv_credits);
return new_credits; return new_credits;
} }
@ -1824,11 +1816,8 @@ static int smb_direct_init_params(struct smb_direct_transport *t,
return -EINVAL; return -EINVAL;
} }
t->recv_credits = 0;
sp->recv_credit_max = smb_direct_receive_credit_max; sp->recv_credit_max = smb_direct_receive_credit_max;
t->recv_credit_target = 1; t->recv_credit_target = 1;
t->new_recv_credits = 0;
sp->send_credit_target = smb_direct_send_credit_target; sp->send_credit_target = smb_direct_send_credit_target;
atomic_set(&sc->rw_io.credits.count, sc->rw_io.credits.max); atomic_set(&sc->rw_io.credits.count, sc->rw_io.credits.max);