From nobody Sun Oct 5 12:49:01 2025 Received: from dggsgout11.his.huawei.com (dggsgout11.his.huawei.com [45.249.212.51]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 0389721CC62; Tue, 5 Aug 2025 06:54:25 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=45.249.212.51 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1754376869; cv=none; b=TolcX5lC8Jsji2AOdCRynjJUJY3iA/5qp0Ut3+jlY9ZBlJbyhI6+Y19+zVNMruQZcS7Pii66BoM+kTK+V7HzE4FwYzCHRy5jmtHhBDwg6VE2BruX9dhyj2nhUcEy7F4TgpZPKQ6lGPYX1QJ9Cslk9NW34VKVyAxMU12WDW7+4TA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1754376869; c=relaxed/simple; bh=OHchsDxfLI6H/RcBK530VV2th9TllWlysNrU6v5xvU4=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=kruinaJHo44LTQnViORVvOBmRmuXyMe9TE0lEXfc+GUnIWeNDyd7rCdFL6cqTkp7+4Uhw5ml5hmfMgbEkQxF+kRvyu2Z5QX9YWTLpMSvzdBUwBDI9PG/7I5q7q9GQ9eJwC7aLLGbM0MZcYGge+TRhCcu1U+iM6tk/gJ6g6mkRyY= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=huaweicloud.com; spf=pass smtp.mailfrom=huaweicloud.com; arc=none smtp.client-ip=45.249.212.51 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=huaweicloud.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=huaweicloud.com Received: from mail.maildlp.com (unknown [172.19.163.235]) by dggsgout11.his.huawei.com (SkyGuard) with ESMTPS id 4bx40c5t2DzYQtwc; Tue, 5 Aug 2025 14:54:24 +0800 (CST) Received: from mail02.huawei.com (unknown [10.116.40.128]) by mail.maildlp.com (Postfix) with ESMTP id 784001A0F38; Tue, 5 Aug 2025 14:54:23 +0800 (CST) Received: from huaweicloud.com (unknown [10.175.104.67]) by APP4 (Coremail) with SMTP id gCh0CgD3chObqpForbmECg--.23530S6; Tue, 05 Aug 2025 14:54:23 +0800 (CST) From: Wang Zhaolong To: sfrench@samba.org, pshilov@microsoft.com Cc: linux-cifs@vger.kernel.org, samba-technical@lists.samba.org, linux-kernel@vger.kernel.org, chengzhihao1@huawei.com, yi.zhang@huawei.com, yangerkun@huawei.com Subject: [PATCH V2 2/4] smb: client: add mid_counter_lock to protect the mid counter counter Date: Tue, 5 Aug 2025 14:47:06 +0800 Message-Id: <20250805064708.332465-3-wangzhaolong@huaweicloud.com> X-Mailer: git-send-email 2.39.2 In-Reply-To: <20250805064708.332465-1-wangzhaolong@huaweicloud.com> References: <20250805064708.332465-1-wangzhaolong@huaweicloud.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-CM-TRANSID: gCh0CgD3chObqpForbmECg--.23530S6 X-Coremail-Antispam: 1UD129KBjvAXoW3ury5tFW7Jw4Dtw1kCw47twb_yoW8Ar15Go Wvqw13uw4UJryUKr98trn3JF1xX348tFWUJFWjqF1Uua4Fk34UAa48Zr15tFWa93y5tr4Y v3yxJa97uas3Ja97n29KB7ZKAUJUUUU8529EdanIXcx71UUUUU7v73VFW2AGmfu7bjvjm3 AaLaJ3UjIYCTnIWjp_UUUYL7kC6x804xWl14x267AKxVWrJVCq3wAFc2x0x2IEx4CE42xK 8VAvwI8IcIk0rVWrJVCq3wAFIxvE14AKwVWUJVWUGwA2048vs2IY020E87I2jVAFwI0_Jr yl82xGYIkIc2x26xkF7I0E14v26r4j6ryUM28lY4IEw2IIxxk0rwA2F7IY1VAKz4vEj48v e4kI8wA2z4x0Y4vE2Ix0cI8IcVAFwI0_tr0E3s1l84ACjcxK6xIIjxv20xvEc7CjxVAFwI 0_Gr1j6F4UJwA2z4x0Y4vEx4A2jsIE14v26rxl6s0DM28EF7xvwVC2z280aVCY1x0267AK xVW0oVCq3wAS0I0E0xvYzxvE52x082IY62kv0487Mc02F40EFcxC0VAKzVAqx4xG6I80ew Av7VC0I7IYx2IY67AKxVWUJVWUGwAv7VC2z280aVAFwI0_Jr0_Gr1lOx8S6xCaFVCjc4AY 6r1j6r4UM4x0Y48IcxkI7VAKI48JMxkF7I0En4kS14v26r126r1DMxAIw28IcxkI7VAKI4 8JMxC20s026xCaFVCjc4AY6r1j6r4UMI8I3I0E5I8CrVAFwI0_Jr0_Jr4lx2IqxVCjr7xv wVAFwI0_JrI_JrWlx4CE17CEb7AF67AKxVWUtVW8ZwCIc40Y0x0EwIxGrwCI42IY6xIIjx v20xvE14v26r1j6r1xMIIF0xvE2Ix0cI8IcVCY1x0267AKxVW8JVWxJwCI42IY6xAIw20E Y4v20xvaj40_Jr0_JF4lIxAIcVC2z280aVAFwI0_Jr0_Gr1lIxAIcVC2z280aVCY1x0267 AKxVW8JVW8JrUvcSsGvfC2KfnxnUUI43ZEXa7IU89NVDUUUUU== X-CM-SenderInfo: pzdqw6xkdrz0tqj6x35dzhxuhorxvhhfrp/ Content-Type: text/plain; charset="utf-8" This is step 2/4 of a patch series to fix mid_q_entry memory leaks caused by race conditions in callback execution. Add a dedicated mid_counter_lock to protect current_mid counter, separating it from mid_queue_lock which protects pending_mid_q operations. This reduces lock contention and prepares for finer- grained locking in subsequent patches. Changes: - Add TCP_Server_Info->mid_counter_lock spinlock - Rename CurrentMid to current_mid for consistency - Use mid_counter_lock to protect current_mid access - Update locking documentation in cifsglob.h This separation allows mid allocation to proceed without blocking queue operations, improving performance under heavy load. Signed-off-by: Wang Zhaolong --- fs/smb/client/cifsglob.h | 5 +++-- fs/smb/client/connect.c | 5 +++-- fs/smb/client/smb1ops.c | 11 ++++++----- fs/smb/client/smb2ops.c | 40 +++++++++++++++++++-------------------- fs/smb/client/transport.c | 12 ++++++------ 5 files changed, 38 insertions(+), 35 deletions(-) diff --git a/fs/smb/client/cifsglob.h b/fs/smb/client/cifsglob.h index ecd568793ce7..1844afdf1e41 100644 --- a/fs/smb/client/cifsglob.h +++ b/fs/smb/client/cifsglob.h @@ -731,10 +731,11 @@ struct TCP_Server_Info { struct net *net; #endif wait_queue_head_t response_q; wait_queue_head_t request_q; /* if more than maxmpx to srvr must block*/ spinlock_t mid_queue_lock; /* protect mid queue */ + spinlock_t mid_counter_lock; struct list_head pending_mid_q; bool noblocksnd; /* use blocking sendmsg */ bool noautotune; /* do not autotune send buf sizes */ bool nosharesock; bool tcp_nodelay; @@ -768,11 +769,11 @@ struct TCP_Server_Info { unsigned int max_rw; /* maxRw specifies the maximum */ /* message size the server can send or receive for */ /* SMB_COM_WRITE_RAW or SMB_COM_READ_RAW. */ unsigned int capabilities; /* selective disabling of caps by smb sess */ int timeAdj; /* Adjust for difference in server time zone in sec */ - __u64 CurrentMid; /* multiplex id - rotating counter, protected b= y GlobalMid_Lock */ + __u64 current_mid; /* multiplex id - rotating counter, protected by mid_c= ounter_lock */ char cryptkey[CIFS_CRYPTO_KEY_SIZE]; /* used by ntlm, ntlmv2 etc */ /* 16th byte of RFC1001 workstation name is always null */ char workstation_RFC1001_name[RFC1001_NAME_LEN_WITH_NULL]; __u32 sequence_number; /* for signing, protected by srv_mutex */ __u32 reconnect_instance; /* incremented on each reconnect */ @@ -2006,12 +2007,12 @@ require use of the stronger protocol */ * GlobalMid_Lock GlobalMaxActiveXid init_cifs * GlobalCurrentXid * GlobalTotalActiveXid * TCP_Server_Info->srv_lock (anything in struct not protected by another = lock and can change) * TCP_Server_Info->mid_queue_lock TCP_Server_Info->pending_mid_q cifs_get= _tcp_session - * ->CurrentMid * (any changes in mid_q_entry fields) + * TCP_Server_Info->mid_counter_lock TCP_Server_Info->current_mid ci= fs_get_tcp_session * TCP_Server_Info->req_lock TCP_Server_Info->in_flight cifs_get_tcp_sessi= on * ->credits * ->echo_credits * ->oplock_credits * ->reconnect_instance diff --git a/fs/smb/client/connect.c b/fs/smb/client/connect.c index e4b577ca48d5..74ad5881ee45 100644 --- a/fs/smb/client/connect.c +++ b/fs/smb/client/connect.c @@ -356,11 +356,11 @@ static bool cifs_tcp_ses_needs_reconnect(struct TCP_S= erver_Info *server, int num wake_up(&server->response_q); return false; } =20 cifs_dbg(FYI, "Mark tcp session as need reconnect\n"); - trace_smb3_reconnect(server->CurrentMid, server->conn_id, + trace_smb3_reconnect(server->current_mid, server->conn_id, server->hostname); server->tcpStatus =3D CifsNeedReconnect; =20 spin_unlock(&server->srv_lock); return true; @@ -1240,11 +1240,11 @@ smb2_add_credits_from_hdr(char *buffer, struct TCP_= Server_Info *server) scredits =3D server->credits; in_flight =3D server->in_flight; spin_unlock(&server->req_lock); wake_up(&server->request_q); =20 - trace_smb3_hdr_credits(server->CurrentMid, + trace_smb3_hdr_credits(server->current_mid, server->conn_id, server->hostname, scredits, le16_to_cpu(shdr->CreditRequest), in_flight); cifs_server_dbg(FYI, "%s: added %u credits total=3D%d\n", __func__, le16_to_cpu(shdr->CreditRequest), scredits); @@ -1821,10 +1821,11 @@ cifs_get_tcp_session(struct smb3_fs_context *ctx, tcp_ses->lstrp =3D jiffies; tcp_ses->compression.requested =3D ctx->compress; spin_lock_init(&tcp_ses->req_lock); spin_lock_init(&tcp_ses->srv_lock); spin_lock_init(&tcp_ses->mid_queue_lock); + spin_lock_init(&tcp_ses->mid_counter_lock); INIT_LIST_HEAD(&tcp_ses->tcp_ses_list); INIT_LIST_HEAD(&tcp_ses->smb_ses_list); INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request); INIT_DELAYED_WORK(&tcp_ses->reconnect, smb2_reconnect_server); mutex_init(&tcp_ses->reconnect_mutex); diff --git a/fs/smb/client/smb1ops.c b/fs/smb/client/smb1ops.c index a1442f697706..13f600a3d0c4 100644 --- a/fs/smb/client/smb1ops.c +++ b/fs/smb/client/smb1ops.c @@ -167,14 +167,13 @@ cifs_get_next_mid(struct TCP_Server_Info *server) { __u64 mid =3D 0; __u16 last_mid, cur_mid; bool collision, reconnect =3D false; =20 - spin_lock(&server->mid_queue_lock); - + spin_lock(&server->mid_counter_lock); /* mid is 16 bit only for CIFS/SMB */ - cur_mid =3D (__u16)((server->CurrentMid) & 0xffff); + cur_mid =3D (__u16)((server->current_mid) & 0xffff); /* we do not want to loop forever */ last_mid =3D cur_mid; cur_mid++; /* avoid 0xFFFF MID */ if (cur_mid =3D=3D 0xffff) @@ -196,19 +195,21 @@ cifs_get_next_mid(struct TCP_Server_Info *server) collision =3D false; if (cur_mid =3D=3D 0) cur_mid++; =20 num_mids =3D 0; + spin_lock(&server->mid_queue_lock); list_for_each_entry(mid_entry, &server->pending_mid_q, qhead) { ++num_mids; if (mid_entry->mid =3D=3D cur_mid && mid_entry->mid_state =3D=3D MID_REQUEST_SUBMITTED) { /* This mid is in use, try a different one */ collision =3D true; break; } } + spin_unlock(&server->mid_queue_lock); =20 /* * if we have more than 32k mids in the list, then something * is very wrong. Possibly a local user is trying to DoS the * box by issuing long-running calls and SIGKILL'ing them. If @@ -221,16 +222,16 @@ cifs_get_next_mid(struct TCP_Server_Info *server) if (num_mids > 32768) reconnect =3D true; =20 if (!collision) { mid =3D (__u64)cur_mid; - server->CurrentMid =3D mid; + server->current_mid =3D mid; break; } cur_mid++; } - spin_unlock(&server->mid_queue_lock); + spin_unlock(&server->mid_counter_lock); =20 if (reconnect) { cifs_signal_cifsd_for_reconnect(server, false); } =20 diff --git a/fs/smb/client/smb2ops.c b/fs/smb/client/smb2ops.c index c714707249c7..da2cb9585404 100644 --- a/fs/smb/client/smb2ops.c +++ b/fs/smb/client/smb2ops.c @@ -89,11 +89,11 @@ smb2_add_credits(struct TCP_Server_Info *server, reconnect_detected =3D true; =20 if (*val > 65000) { *val =3D 65000; /* Don't get near 64K credits, avoid srv bugs */ pr_warn_once("server overflowed SMB3 credits\n"); - trace_smb3_overflow_credits(server->CurrentMid, + trace_smb3_overflow_credits(server->current_mid, server->conn_id, server->hostname, *val, add, server->in_flight); } if (credits->in_flight_check > 1) { pr_warn_once("rreq R=3D%08x[%x] Credits not in flight\n", @@ -134,19 +134,19 @@ smb2_add_credits(struct TCP_Server_Info *server, in_flight =3D server->in_flight; spin_unlock(&server->req_lock); wake_up(&server->request_q); =20 if (reconnect_detected) { - trace_smb3_reconnect_detected(server->CurrentMid, + trace_smb3_reconnect_detected(server->current_mid, server->conn_id, server->hostname, scredits, add, in_flight); =20 cifs_dbg(FYI, "trying to put %d credits from the old server instance %d\= n", add, instance); } =20 if (reconnect_with_invalid_credits) { - trace_smb3_reconnect_with_invalid_credits(server->CurrentMid, + trace_smb3_reconnect_with_invalid_credits(server->current_mid, server->conn_id, server->hostname, scredits, add, in_flight); cifs_dbg(FYI, "Negotiate operation when server credits is non-zero. Opty= pe: %d, server credits: %d, credits added: %d\n", optype, scredits, add); } =20 @@ -174,11 +174,11 @@ smb2_add_credits(struct TCP_Server_Info *server, default: /* change_conf rebalanced credits for different types */ break; } =20 - trace_smb3_add_credits(server->CurrentMid, + trace_smb3_add_credits(server->current_mid, server->conn_id, server->hostname, scredits, add, in_flight); cifs_dbg(FYI, "%s: added %u credits total=3D%d\n", __func__, add, scredit= s); } =20 static void @@ -201,11 +201,11 @@ smb2_set_credits(struct TCP_Server_Info *server, cons= t int val) } scredits =3D server->credits; in_flight =3D server->in_flight; spin_unlock(&server->req_lock); =20 - trace_smb3_set_credits(server->CurrentMid, + trace_smb3_set_credits(server->current_mid, server->conn_id, server->hostname, scredits, val, in_flight); cifs_dbg(FYI, "%s: set %u credits\n", __func__, val); =20 /* don't log while holding the lock */ if (val =3D=3D 1) @@ -286,11 +286,11 @@ smb2_wait_mtu_credits(struct TCP_Server_Info *server,= size_t size, } scredits =3D server->credits; in_flight =3D server->in_flight; spin_unlock(&server->req_lock); =20 - trace_smb3_wait_credits(server->CurrentMid, + trace_smb3_wait_credits(server->current_mid, server->conn_id, server->hostname, scredits, -(credits->value), in_flig= ht); cifs_dbg(FYI, "%s: removed %u credits total=3D%d\n", __func__, credits->value, scredits); =20 return rc; @@ -314,11 +314,11 @@ smb2_adjust_credits(struct TCP_Server_Info *server, subreq->subreq.debug_index, credits->value, server->credits, server->in_flight, new_val - credits->value, cifs_trace_rw_credits_no_adjust_up); - trace_smb3_too_many_credits(server->CurrentMid, + trace_smb3_too_many_credits(server->current_mid, server->conn_id, server->hostname, 0, credits->value - new_val, 0); cifs_server_dbg(VFS, "R=3D%x[%x] request has less credits (%d) than requ= ired (%d)", subreq->rreq->debug_id, subreq->subreq.debug_index, credits->value, new_val); =20 @@ -336,11 +336,11 @@ smb2_adjust_credits(struct TCP_Server_Info *server, subreq->subreq.debug_index, credits->value, server->credits, server->in_flight, new_val - credits->value, cifs_trace_rw_credits_old_session); - trace_smb3_reconnect_detected(server->CurrentMid, + trace_smb3_reconnect_detected(server->current_mid, server->conn_id, server->hostname, scredits, credits->value - new_val, in_flight); cifs_server_dbg(VFS, "R=3D%x[%x] trying to return %d credits to old sess= ion\n", subreq->rreq->debug_id, subreq->subreq.debug_index, credits->value - new_val); @@ -356,11 +356,11 @@ smb2_adjust_credits(struct TCP_Server_Info *server, scredits =3D server->credits; in_flight =3D server->in_flight; spin_unlock(&server->req_lock); wake_up(&server->request_q); =20 - trace_smb3_adj_credits(server->CurrentMid, + trace_smb3_adj_credits(server->current_mid, server->conn_id, server->hostname, scredits, credits->value - new_val, in_flight); cifs_dbg(FYI, "%s: adjust added %u credits total=3D%d\n", __func__, credits->value - new_val, scredits); =20 @@ -372,23 +372,23 @@ smb2_adjust_credits(struct TCP_Server_Info *server, static __u64 smb2_get_next_mid(struct TCP_Server_Info *server) { __u64 mid; /* for SMB2 we need the current value */ - spin_lock(&server->mid_queue_lock); - mid =3D server->CurrentMid++; - spin_unlock(&server->mid_queue_lock); + spin_lock(&server->mid_counter_lock); + mid =3D server->current_mid++; + spin_unlock(&server->mid_counter_lock); return mid; } =20 static void smb2_revert_current_mid(struct TCP_Server_Info *server, const unsigned int= val) { - spin_lock(&server->mid_queue_lock); - if (server->CurrentMid >=3D val) - server->CurrentMid -=3D val; - spin_unlock(&server->mid_queue_lock); + spin_lock(&server->mid_counter_lock); + if (server->current_mid >=3D val) + server->current_mid -=3D val; + spin_unlock(&server->mid_counter_lock); } =20 static struct mid_q_entry * __smb2_find_mid(struct TCP_Server_Info *server, char *buf, bool dequeue) { @@ -458,13 +458,13 @@ smb2_negotiate(const unsigned int xid, struct cifs_ses *ses, struct TCP_Server_Info *server) { int rc; =20 - spin_lock(&server->mid_queue_lock); - server->CurrentMid =3D 0; - spin_unlock(&server->mid_queue_lock); + spin_lock(&server->mid_counter_lock); + server->current_mid =3D 0; + spin_unlock(&server->mid_counter_lock); rc =3D SMB2_negotiate(xid, ses, server); return rc; } =20 static inline unsigned int @@ -2496,11 +2496,11 @@ smb2_is_status_pending(char *buf, struct TCP_Server= _Info *server) scredits =3D server->credits; in_flight =3D server->in_flight; spin_unlock(&server->req_lock); wake_up(&server->request_q); =20 - trace_smb3_pend_credits(server->CurrentMid, + trace_smb3_pend_credits(server->current_mid, server->conn_id, server->hostname, scredits, le16_to_cpu(shdr->CreditRequest), in_flight); cifs_dbg(FYI, "%s: status pending add %u credits total=3D%d\n", __func__, le16_to_cpu(shdr->CreditRequest), scredits); } diff --git a/fs/smb/client/transport.c b/fs/smb/client/transport.c index 12dc927aa4a2..8037accc3987 100644 --- a/fs/smb/client/transport.c +++ b/fs/smb/client/transport.c @@ -395,11 +395,11 @@ __smb_send_rqst(struct TCP_Server_Info *server, int n= um_rqst, * If we have only sent part of an SMB then the next SMB could * be taken as the remainder of this one. We need to kill the * socket so the server throws away the partial SMB */ cifs_signal_cifsd_for_reconnect(server, false); - trace_smb3_partial_send_reconnect(server->CurrentMid, + trace_smb3_partial_send_reconnect(server->current_mid, server->conn_id, server->hostname); } smbd_done: /* * there's hardly any use for the layers above to know the @@ -507,11 +507,11 @@ wait_for_free_credits(struct TCP_Server_Info *server,= const int num_credits, *instance =3D server->reconnect_instance; scredits =3D *credits; in_flight =3D server->in_flight; spin_unlock(&server->req_lock); =20 - trace_smb3_nblk_credits(server->CurrentMid, + trace_smb3_nblk_credits(server->current_mid, server->conn_id, server->hostname, scredits, -1, in_flight); cifs_dbg(FYI, "%s: remove %u credits total=3D%d\n", __func__, 1, scredits); =20 return 0; @@ -540,11 +540,11 @@ wait_for_free_credits(struct TCP_Server_Info *server,= const int num_credits, spin_lock(&server->req_lock); scredits =3D *credits; in_flight =3D server->in_flight; spin_unlock(&server->req_lock); =20 - trace_smb3_credit_timeout(server->CurrentMid, + trace_smb3_credit_timeout(server->current_mid, server->conn_id, server->hostname, scredits, num_credits, in_flight); cifs_server_dbg(VFS, "wait timed out after %d ms\n", timeout); return -EBUSY; @@ -583,11 +583,11 @@ wait_for_free_credits(struct TCP_Server_Info *server,= const int num_credits, scredits =3D *credits; in_flight =3D server->in_flight; spin_unlock(&server->req_lock); =20 trace_smb3_credit_timeout( - server->CurrentMid, + server->current_mid, server->conn_id, server->hostname, scredits, num_credits, in_flight); cifs_server_dbg(VFS, "wait timed out after %d ms\n", timeout); return -EBUSY; @@ -613,11 +613,11 @@ wait_for_free_credits(struct TCP_Server_Info *server,= const int num_credits, } scredits =3D *credits; in_flight =3D server->in_flight; spin_unlock(&server->req_lock); =20 - trace_smb3_waitff_credits(server->CurrentMid, + trace_smb3_waitff_credits(server->current_mid, server->conn_id, server->hostname, scredits, -(num_credits), in_flight); cifs_dbg(FYI, "%s: remove %u credits total=3D%d\n", __func__, num_credits, scredits); break; @@ -664,11 +664,11 @@ wait_for_compound_request(struct TCP_Server_Info *ser= ver, int num, * Return immediately if no requests in flight since we will be * stuck on waiting for credits. */ if (server->in_flight =3D=3D 0) { spin_unlock(&server->req_lock); - trace_smb3_insufficient_credits(server->CurrentMid, + trace_smb3_insufficient_credits(server->current_mid, server->conn_id, server->hostname, scredits, num, in_flight); cifs_dbg(FYI, "%s: %d requests in flight, needed %d total=3D%d\n", __func__, in_flight, num, scredits); return -EDEADLK; --=20 2.39.2