History

cifs: fix potential deadlock in direct reclaim

The srv_mutex is used during writeback so cifs should ensure that allocations done when that mutex is held are done with GFP_NOFS, to avoid having direct reclaim ending up waiting for the same mutex and causing a deadlock. This is detected by lockdep with the splat below: ====================================================== WARNING: possible circular locking dependency detected 5.18.0 #70 Not tainted ------------------------------------------------------ kswapd0/49 is trying to acquire lock: ffff8880195782e0 (&tcp_ses->srv_mutex){+.+.}-{3:3}, at: compound_send_recv but task is already holding lock: ffffffffa98e66c0 (fs_reclaim){+.+.}-{0:0}, at: balance_pgdat which lock already depends on the new lock. the existing dependency chain (in reverse order) is: -> #1 (fs_reclaim){+.+.}-{0:0}: fs_reclaim_acquire kmem_cache_alloc_trace __request_module crypto_alg_mod_lookup crypto_alloc_tfm_node crypto_alloc_shash cifs_alloc_hash smb311_crypto_shash_allocate smb311_update_preauth_hash compound_send_recv cifs_send_recv SMB2_negotiate smb2_negotiate cifs_negotiate_protocol cifs_get_smb_ses cifs_mount cifs_smb3_do_mount smb3_get_tree vfs_get_tree path_mount __x64_sys_mount do_syscall_64 entry_SYSCALL_64_after_hwframe -> #0 (&tcp_ses->srv_mutex){+.+.}-{3:3}: __lock_acquire lock_acquire __mutex_lock mutex_lock_nested compound_send_recv cifs_send_recv SMB2_write smb2_sync_write cifs_write cifs_writepage_locked cifs_writepage shrink_page_list shrink_lruvec shrink_node balance_pgdat kswapd kthread ret_from_fork other info that might help us debug this: Possible unsafe locking scenario: CPU0 CPU1 ---- ---- lock(fs_reclaim); lock(&tcp_ses->srv_mutex); lock(fs_reclaim); lock(&tcp_ses->srv_mutex); *** DEADLOCK *** 1 lock held by kswapd0/49: #0: ffffffffa98e66c0 (fs_reclaim){+.+.}-{0:0}, at: balance_pgdat stack backtrace: CPU: 2 PID: 49 Comm: kswapd0 Not tainted 5.18.0 #70 Call Trace: <TASK> dump_stack_lvl dump_stack print_circular_bug.cold check_noncircular __lock_acquire lock_acquire __mutex_lock mutex_lock_nested compound_send_recv cifs_send_recv SMB2_write smb2_sync_write cifs_write cifs_writepage_locked cifs_writepage shrink_page_list shrink_lruvec shrink_node balance_pgdat kswapd kthread ret_from_fork </TASK> Fix this by using the memalloc_nofs_save/restore APIs around the places where the srv_mutex is held. Do this in a wrapper function for the lock/unlock of the srv_mutex, and rename the srv_mutex to avoid missing call sites in the conversion. Note that there is another lockdep warning involving internal crypto locks, which was masked by this problem and is visible after this fix, see the discussion in this thread: https://lore.kernel.org/all/20220523123755.GA13668@axis.com/

Vincent Whitchurch committed 4 years ago

Commit cc391b61 parent f66f8b910 files · +71 −53Browse files

Unified · Split

10 files
  1. fs/cifs/cifs_swn.c +2 −2
  2. fs/cifs/cifsencrypt.c +4 −4
  3. fs/cifs/cifsglob.h +19 −1
  4. fs/cifs/connect.c +13 −13
  5. fs/cifs/dfs_cache.c +2 −2
  6. fs/cifs/sess.c +3 −3
  7. fs/cifs/smb1ops.c +3 −3
  8. fs/cifs/smb2pdu.c +3 −3
  9. fs/cifs/smbdirect.c +2 −2
  10. fs/cifs/transport.c +20 −20
fs/cifs/cifs_swn.c+2−2
@@ -465,7 +465,7 @@ static int cifs_swn_reconnect(struct cifs_tcon *tcon, struct sockaddr_storage *a · 464 unmodified lines
465465 int ret = 0;
466466
467467 /* Store the reconnect address */
468− mutex_lock(&tcon->ses->server->srv_mutex);
468+ cifs_server_lock(tcon->ses->server);
469469 if (cifs_sockaddr_equal(&tcon->ses->server->dstaddr, addr))
470470 goto unlock;
471471
@@ -501,7 +501,7 @@ static int cifs_swn_reconnect(struct cifs_tcon *tcon, struct sockaddr_storage *a · 29 unmodified lines
501501 cifs_signal_cifsd_for_reconnect(tcon->ses->server, false);
502502
503503 unlock:
504− mutex_unlock(&tcon->ses->server->srv_mutex);
504+ cifs_server_unlock(tcon->ses->server);
505505
506506 return ret;
507507 }
fs/cifs/cifsencrypt.c+4−4
@@ -236,9 +236,9 @@ int cifs_verify_signature(struct smb_rqst *rqst, · 235 unmodified lines
236236 cpu_to_le32(expected_sequence_number);
237237 cifs_pdu->Signature.Sequence.Reserved = 0;
238238
239− mutex_lock(&server->srv_mutex);
239+ cifs_server_lock(server);
240240 rc = cifs_calc_signature(rqst, server, what_we_think_sig_should_be);
241− mutex_unlock(&server->srv_mutex);
241+ cifs_server_unlock(server);
242242
243243 if (rc)
244244 return rc;
@@ -626,7 +626,7 @@ setup_ntlmv2_rsp(struct cifs_ses *ses, const struct nls_table *nls_cp) · 381 unmodified lines
626626
627627 memcpy(ses->auth_key.response + baselen, tiblob, tilen);
628628
629− mutex_lock(&ses->server->srv_mutex);
629+ cifs_server_lock(ses->server);
630630
631631 rc = cifs_alloc_hash("hmac(md5)",
632632 &ses->server->secmech.hmacmd5,
@@ -678,7 +678,7 @@ setup_ntlmv2_rsp(struct cifs_ses *ses, const struct nls_table *nls_cp) · 45 unmodified lines
678678 cifs_dbg(VFS, "%s: Could not generate md5 hash\n", __func__);
679679
680680 unlock:
681− mutex_unlock(&ses->server->srv_mutex);
681+ cifs_server_unlock(ses->server);
682682 setup_ntlmv2_rsp_ret:
683683 kfree(tiblob);
684684
fs/cifs/cifsglob.h+19−1
@@ -16,6 +16,7 @@ · 15 unmodified lines
1616 #include <linux/mempool.h>
1717 #include <linux/workqueue.h>
1818 #include <linux/utsname.h>
19+#include <linux/sched/mm.h>
1920 #include <linux/netfs.h>
2021 #include "cifs_fs_sb.h"
2122 #include "cifsacl.h"
@@ -628,7 +629,8 @@ struct TCP_Server_Info { · 606 unmodified lines
628629 unsigned int in_flight; /* number of requests on the wire to server */
629630 unsigned int max_in_flight; /* max number of requests that were on wire */
630631 spinlock_t req_lock; /* protect the two values above */
631− struct mutex srv_mutex;
632+ struct mutex _srv_mutex;
633+ unsigned int nofs_flag;
632634 struct task_struct *tsk;
633635 char server_GUID[16];
634636 __u16 sec_mode;
@@ -743,6 +745,22 @@ struct TCP_Server_Info { · 108 unmodified lines
743745 #endif
744746 };
745747
748+static inline void cifs_server_lock(struct TCP_Server_Info *server)
749+{
750+ unsigned int nofs_flag = memalloc_nofs_save();
751+
752+ mutex_lock(&server->_srv_mutex);
753+ server->nofs_flag = nofs_flag;
754+}
755+
756+static inline void cifs_server_unlock(struct TCP_Server_Info *server)
757+{
758+ unsigned int nofs_flag = server->nofs_flag;
759+
760+ mutex_unlock(&server->_srv_mutex);
761+ memalloc_nofs_restore(nofs_flag);
762+}
763+
746764 struct cifs_credits {
747765 unsigned int value;
748766 unsigned int instance;
fs/cifs/connect.c+13−13
@@ -148,7 +148,7 @@ static void cifs_resolve_server(struct work_struct *work) · 147 unmodified lines
148148 struct TCP_Server_Info *server = container_of(work,
149149 struct TCP_Server_Info, resolve.work);
150150
151− mutex_lock(&server->srv_mutex);
151+ cifs_server_lock(server);
152152
153153 /*
154154 * Resolve the hostname again to make sure that IP address is up-to-date.
@@ -159,7 +159,7 @@ static void cifs_resolve_server(struct work_struct *work) · 4 unmodified lines
159159 __func__, rc);
160160 }
161161
162− mutex_unlock(&server->srv_mutex);
162+ cifs_server_unlock(server);
163163 }
164164
165165 /*
@@ -267,7 +267,7 @@ cifs_abort_connection(struct TCP_Server_Info *server) · 101 unmodified lines
267267
268268 /* do not want to be sending data on a socket we are freeing */
269269 cifs_dbg(FYI, "%s: tearing down socket\n", __func__);
270− mutex_lock(&server->srv_mutex);
270+ cifs_server_lock(server);
271271 if (server->ssocket) {
272272 cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n", server->ssocket->state,
273273 server->ssocket->flags);
@@ -296,7 +296,7 @@ cifs_abort_connection(struct TCP_Server_Info *server) · 22 unmodified lines
296296 mid->mid_flags |= MID_DELETED;
297297 }
298298 spin_unlock(&GlobalMid_Lock);
299− mutex_unlock(&server->srv_mutex);
299+ cifs_server_unlock(server);
300300
301301 cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__);
302302 list_for_each_entry_safe(mid, nmid, &retry_list, qhead) {
@@ -306,9 +306,9 @@ cifs_abort_connection(struct TCP_Server_Info *server) · 3 unmodified lines
306306 }
307307
308308 if (cifs_rdma_enabled(server)) {
309− mutex_lock(&server->srv_mutex);
309+ cifs_server_lock(server);
310310 smbd_destroy(server);
311− mutex_unlock(&server->srv_mutex);
311+ cifs_server_unlock(server);
312312 }
313313 }
314314
@@ -359,7 +359,7 @@ static int __cifs_reconnect(struct TCP_Server_Info *server, · 44 unmodified lines
359359
360360 do {
361361 try_to_freeze();
362− mutex_lock(&server->srv_mutex);
362+ cifs_server_lock(server);
363363
364364 if (!cifs_swn_set_server_dstaddr(server)) {
365365 /* resolve the hostname again to make sure that IP address is up-to-date */
@@ -372,7 +372,7 @@ static int __cifs_reconnect(struct TCP_Server_Info *server, · 6 unmodified lines
372372 else
373373 rc = generic_ip_connect(server);
374374 if (rc) {
375− mutex_unlock(&server->srv_mutex);
375+ cifs_server_unlock(server);
376376 cifs_dbg(FYI, "%s: reconnect error %d\n", __func__, rc);
377377 msleep(3000);
378378 } else {
@@ -383,7 +383,7 @@ static int __cifs_reconnect(struct TCP_Server_Info *server, · 4 unmodified lines
383383 server->tcpStatus = CifsNeedNegotiate;
384384 spin_unlock(&cifs_tcp_ses_lock);
385385 cifs_swn_reset_server_dstaddr(server);
386− mutex_unlock(&server->srv_mutex);
386+ cifs_server_unlock(server);
387387 mod_delayed_work(cifsiod_wq, &server->reconnect, 0);
388388 }
389389 } while (server->tcpStatus == CifsNeedReconnect);
@@ -488,12 +488,12 @@ static int reconnect_dfs_server(struct TCP_Server_Info *server) · 98 unmodified lines
488488
489489 do {
490490 try_to_freeze();
491− mutex_lock(&server->srv_mutex);
491+ cifs_server_lock(server);
492492
493493 rc = reconnect_target_unlocked(server, &tl, &target_hint);
494494 if (rc) {
495495 /* Failed to reconnect socket */
496− mutex_unlock(&server->srv_mutex);
496+ cifs_server_unlock(server);
497497 cifs_dbg(FYI, "%s: reconnect error %d\n", __func__, rc);
498498 msleep(3000);
499499 continue;
@@ -510,7 +510,7 @@ static int reconnect_dfs_server(struct TCP_Server_Info *server) · 10 unmodified lines
510510 server->tcpStatus = CifsNeedNegotiate;
511511 spin_unlock(&cifs_tcp_ses_lock);
512512 cifs_swn_reset_server_dstaddr(server);
513− mutex_unlock(&server->srv_mutex);
513+ cifs_server_unlock(server);
514514 mod_delayed_work(cifsiod_wq, &server->reconnect, 0);
515515 } while (server->tcpStatus == CifsNeedReconnect);
516516
@@ -1565,7 +1565,7 @@ cifs_get_tcp_session(struct smb3_fs_context *ctx, · 1048 unmodified lines
15651565 init_waitqueue_head(&tcp_ses->response_q);
15661566 init_waitqueue_head(&tcp_ses->request_q);
15671567 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1568− mutex_init(&tcp_ses->srv_mutex);
1568+ mutex_init(&tcp_ses->_srv_mutex);
15691569 memcpy(tcp_ses->workstation_RFC1001_name,
15701570 ctx->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
15711571 memcpy(tcp_ses->server_RFC1001_name,
fs/cifs/dfs_cache.c+2−2
@@ -1327,9 +1327,9 @@ static bool target_share_equal(struct TCP_Server_Info *server, const char *s1, c · 1326 unmodified lines
13271327 cifs_dbg(VFS, "%s: failed to convert address \'%s\'. skip address matching.\n",
13281328 __func__, ip);
13291329 } else {
1330− mutex_lock(&server->srv_mutex);
1330+ cifs_server_lock(server);
13311331 match = cifs_match_ipaddr((struct sockaddr *)&server->dstaddr, &sa);
1332− mutex_unlock(&server->srv_mutex);
1332+ cifs_server_unlock(server);
13331333 }
13341334
13351335 kfree(ip);
fs/cifs/sess.c+3−3
@@ -1120,14 +1120,14 @@ sess_establish_session(struct sess_data *sess_data) · 1119 unmodified lines
11201120 struct cifs_ses *ses = sess_data->ses;
11211121 struct TCP_Server_Info *server = sess_data->server;
11221122
1123− mutex_lock(&server->srv_mutex);
1123+ cifs_server_lock(server);
11241124 if (!server->session_estab) {
11251125 if (server->sign) {
11261126 server->session_key.response =
11271127 kmemdup(ses->auth_key.response,
11281128 ses->auth_key.len, GFP_KERNEL);
11291129 if (!server->session_key.response) {
1130− mutex_unlock(&server->srv_mutex);
1130+ cifs_server_unlock(server);
11311131 return -ENOMEM;
11321132 }
11331133 server->session_key.len =
@@ -1136,7 +1136,7 @@ sess_establish_session(struct sess_data *sess_data) · 2 unmodified lines
11361136 server->sequence_number = 0x2;
11371137 server->session_estab = true;
11381138 }
1139− mutex_unlock(&server->srv_mutex);
1139+ cifs_server_unlock(server);
11401140
11411141 cifs_dbg(FYI, "CIFS session established successfully\n");
11421142 return 0;
fs/cifs/smb1ops.c+3−3
@@ -38,10 +38,10 @@ send_nt_cancel(struct TCP_Server_Info *server, struct smb_rqst *rqst, · 37 unmodified lines
3838 in_buf->WordCount = 0;
3939 put_bcc(0, in_buf);
4040
41− mutex_lock(&server->srv_mutex);
41+ cifs_server_lock(server);
4242 rc = cifs_sign_smb(in_buf, server, &mid->sequence_number);
4343 if (rc) {
44− mutex_unlock(&server->srv_mutex);
44+ cifs_server_unlock(server);
4545 return rc;
4646 }
4747
@@ -55,7 +55,7 @@ send_nt_cancel(struct TCP_Server_Info *server, struct smb_rqst *rqst, · 7 unmodified lines
5555 if (rc < 0)
5656 server->sequence_number--;
5757
58− mutex_unlock(&server->srv_mutex);
58+ cifs_server_unlock(server);
5959
6060 cifs_dbg(FYI, "issued NT_CANCEL for mid %u, rc = %d\n",
6161 get_mid(in_buf), rc);
fs/cifs/smb2pdu.c+3−3
@@ -1369,13 +1369,13 @@ SMB2_sess_establish_session(struct SMB2_sess_data *sess_data) · 1368 unmodified lines
13691369 struct cifs_ses *ses = sess_data->ses;
13701370 struct TCP_Server_Info *server = sess_data->server;
13711371
1372− mutex_lock(&server->srv_mutex);
1372+ cifs_server_lock(server);
13731373 if (server->ops->generate_signingkey) {
13741374 rc = server->ops->generate_signingkey(ses, server);
13751375 if (rc) {
13761376 cifs_dbg(FYI,
13771377 "SMB3 session key generation failed\n");
1378− mutex_unlock(&server->srv_mutex);
1378+ cifs_server_unlock(server);
13791379 return rc;
13801380 }
13811381 }
@@ -1383,7 +1383,7 @@ SMB2_sess_establish_session(struct SMB2_sess_data *sess_data) · 1 unmodified line
13831383 server->sequence_number = 0x2;
13841384 server->session_estab = true;
13851385 }
1386− mutex_unlock(&server->srv_mutex);
1386+ cifs_server_unlock(server);
13871387
13881388 cifs_dbg(FYI, "SMB2/3 session established successfully\n");
13891389 return rc;
fs/cifs/smbdirect.c+2−2
@@ -1382,9 +1382,9 @@ void smbd_destroy(struct TCP_Server_Info *server) · 1381 unmodified lines
13821382 log_rdma_event(INFO, "freeing mr list\n");
13831383 wake_up_interruptible_all(&info->wait_mr);
13841384 while (atomic_read(&info->mr_used_count)) {
1385− mutex_unlock(&server->srv_mutex);
1385+ cifs_server_unlock(server);
13861386 msleep(1000);
1387− mutex_lock(&server->srv_mutex);
1387+ cifs_server_lock(server);
13881388 }
13891389 destroy_mr_list(info);
13901390
fs/cifs/transport.c+20−20
@@ -822,7 +822,7 @@ cifs_call_async(struct TCP_Server_Info *server, struct smb_rqst *rqst, · 821 unmodified lines
822822 } else
823823 instance = exist_credits->instance;
824824
825− mutex_lock(&server->srv_mutex);
825+ cifs_server_lock(server);
826826
827827 /*
828828 * We can't use credits obtained from the previous session to send this
@@ -830,14 +830,14 @@ cifs_call_async(struct TCP_Server_Info *server, struct smb_rqst *rqst, · 1 unmodified line
830830 * return -EAGAIN in such cases to let callers handle it.
831831 */
832832 if (instance != server->reconnect_instance) {
833− mutex_unlock(&server->srv_mutex);
833+ cifs_server_unlock(server);
834834 add_credits_and_wake_if(server, &credits, optype);
835835 return -EAGAIN;
836836 }
837837
838838 mid = server->ops->setup_async_request(server, rqst);
839839 if (IS_ERR(mid)) {
840− mutex_unlock(&server->srv_mutex);
840+ cifs_server_unlock(server);
841841 add_credits_and_wake_if(server, &credits, optype);
842842 return PTR_ERR(mid);
843843 }
@@ -868,7 +868,7 @@ cifs_call_async(struct TCP_Server_Info *server, struct smb_rqst *rqst, · 24 unmodified lines
868868 cifs_delete_mid(mid);
869869 }
870870
871− mutex_unlock(&server->srv_mutex);
871+ cifs_server_unlock(server);
872872
873873 if (rc == 0)
874874 return 0;
@@ -1109,7 +1109,7 @@ compound_send_recv(const unsigned int xid, struct cifs_ses *ses, · 234 unmodified lines
11091109 * of smb data.
11101110 */
11111111
1112− mutex_lock(&server->srv_mutex);
1112+ cifs_server_lock(server);
11131113
11141114 /*
11151115 * All the parts of the compound chain belong obtained credits from the
@@ -1119,7 +1119,7 @@ compound_send_recv(const unsigned int xid, struct cifs_ses *ses, · 3 unmodified lines
11191119 * handle it.
11201120 */
11211121 if (instance != server->reconnect_instance) {
1122− mutex_unlock(&server->srv_mutex);
1122+ cifs_server_unlock(server);
11231123 for (j = 0; j < num_rqst; j++)
11241124 add_credits(server, &credits[j], optype);
11251125 return -EAGAIN;
@@ -1131,7 +1131,7 @@ compound_send_recv(const unsigned int xid, struct cifs_ses *ses, · 5 unmodified lines
11311131 revert_current_mid(server, i);
11321132 for (j = 0; j < i; j++)
11331133 cifs_delete_mid(midQ[j]);
1134− mutex_unlock(&server->srv_mutex);
1134+ cifs_server_unlock(server);
11351135
11361136 /* Update # of requests on wire to server */
11371137 for (j = 0; j < num_rqst; j++)
@@ -1163,7 +1163,7 @@ compound_send_recv(const unsigned int xid, struct cifs_ses *ses, · 25 unmodified lines
11631163 server->sequence_number -= 2;
11641164 }
11651165
1166− mutex_unlock(&server->srv_mutex);
1166+ cifs_server_unlock(server);
11671167
11681168 /*
11691169 * If sending failed for some reason or it is an oplock break that we
@@ -1190,9 +1190,9 @@ compound_send_recv(const unsigned int xid, struct cifs_ses *ses, · 20 unmodified lines
11901190 if ((ses->ses_status == SES_NEW) || (optype & CIFS_NEG_OP) || (optype & CIFS_SESS_OP)) {
11911191 spin_unlock(&cifs_tcp_ses_lock);
11921192
1193− mutex_lock(&server->srv_mutex);
1193+ cifs_server_lock(server);
11941194 smb311_update_preauth_hash(ses, server, rqst[0].rq_iov, rqst[0].rq_nvec);
1195− mutex_unlock(&server->srv_mutex);
1195+ cifs_server_unlock(server);
11961196
11971197 spin_lock(&cifs_tcp_ses_lock);
11981198 }
@@ -1266,9 +1266,9 @@ compound_send_recv(const unsigned int xid, struct cifs_ses *ses, · 67 unmodified lines
12661266 .iov_len = resp_iov[0].iov_len
12671267 };
12681268 spin_unlock(&cifs_tcp_ses_lock);
1269− mutex_lock(&server->srv_mutex);
1269+ cifs_server_lock(server);
12701270 smb311_update_preauth_hash(ses, server, &iov, 1);
1271− mutex_unlock(&server->srv_mutex);
1271+ cifs_server_unlock(server);
12721272 spin_lock(&cifs_tcp_ses_lock);
12731273 }
12741274 spin_unlock(&cifs_tcp_ses_lock);
@@ -1385,11 +1385,11 @@ SendReceive(const unsigned int xid, struct cifs_ses *ses, · 110 unmodified lines
13851385 and avoid races inside tcp sendmsg code that could cause corruption
13861386 of smb data */
13871387
1388− mutex_lock(&server->srv_mutex);
1388+ cifs_server_lock(server);
13891389
13901390 rc = allocate_mid(ses, in_buf, &midQ);
13911391 if (rc) {
1392− mutex_unlock(&server->srv_mutex);
1392+ cifs_server_unlock(server);
13931393 /* Update # of requests on wire to server */
13941394 add_credits(server, &credits, 0);
13951395 return rc;
@@ -1397,7 +1397,7 @@ SendReceive(const unsigned int xid, struct cifs_ses *ses, · 1 unmodified line
13971397
13981398 rc = cifs_sign_smb(in_buf, server, &midQ->sequence_number);
13991399 if (rc) {
1400− mutex_unlock(&server->srv_mutex);
1400+ cifs_server_unlock(server);
14011401 goto out;
14021402 }
14031403
@@ -1411,7 +1411,7 @@ SendReceive(const unsigned int xid, struct cifs_ses *ses, · 7 unmodified lines
14111411 if (rc < 0)
14121412 server->sequence_number -= 2;
14131413
1414− mutex_unlock(&server->srv_mutex);
1414+ cifs_server_unlock(server);
14151415
14161416 if (rc < 0)
14171417 goto out;
@@ -1530,18 +1530,18 @@ SendReceiveBlockingLock(const unsigned int xid, struct cifs_tcon *tcon, · 112 unmodified lines
15301530 and avoid races inside tcp sendmsg code that could cause corruption
15311531 of smb data */
15321532
1533− mutex_lock(&server->srv_mutex);
1533+ cifs_server_lock(server);
15341534
15351535 rc = allocate_mid(ses, in_buf, &midQ);
15361536 if (rc) {
1537− mutex_unlock(&server->srv_mutex);
1537+ cifs_server_unlock(server);
15381538 return rc;
15391539 }
15401540
15411541 rc = cifs_sign_smb(in_buf, server, &midQ->sequence_number);
15421542 if (rc) {
15431543 cifs_delete_mid(midQ);
1544− mutex_unlock(&server->srv_mutex);
1544+ cifs_server_unlock(server);
15451545 return rc;
15461546 }
15471547
@@ -1554,7 +1554,7 @@ SendReceiveBlockingLock(const unsigned int xid, struct cifs_tcon *tcon, · 6 unmodified lines
15541554 if (rc < 0)
15551555 server->sequence_number -= 2;
15561556
1557− mutex_unlock(&server->srv_mutex);
1557+ cifs_server_unlock(server);
15581558
15591559 if (rc < 0) {
15601560 cifs_delete_mid(midQ);

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t