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
465 int ret = 0;465 int ret = 0;
466 466
467 /* Store the reconnect address */467 /* Store the reconnect address */
468 mutex_lock(&tcon->ses->server->srv_mutex);468 cifs_server_lock(tcon->ses->server);
469 if (cifs_sockaddr_equal(&tcon->ses->server->dstaddr, addr))469 if (cifs_sockaddr_equal(&tcon->ses->server->dstaddr, addr))
470 goto unlock;470 goto unlock;
471 471
@@ -501,7 +501,7 @@ static int cifs_swn_reconnect(struct cifs_tcon *tcon, struct sockaddr_storage *a · 29 unmodified lines
501 cifs_signal_cifsd_for_reconnect(tcon->ses->server, false);501 cifs_signal_cifsd_for_reconnect(tcon->ses->server, false);
502 502
503unlock:503unlock:
504 mutex_unlock(&tcon->ses->server->srv_mutex);504 cifs_server_unlock(tcon->ses->server);
505 505
506 return ret;506 return ret;
507}507}
fs/cifs/cifsencrypt.c+4−4
@@ -236,9 +236,9 @@ int cifs_verify_signature(struct smb_rqst *rqst, · 235 unmodified lines
236 cpu_to_le32(expected_sequence_number);236 cpu_to_le32(expected_sequence_number);
237 cifs_pdu->Signature.Sequence.Reserved = 0;237 cifs_pdu->Signature.Sequence.Reserved = 0;
238 238
239 mutex_lock(&server->srv_mutex);239 cifs_server_lock(server);
240 rc = cifs_calc_signature(rqst, server, what_we_think_sig_should_be);240 rc = cifs_calc_signature(rqst, server, what_we_think_sig_should_be);
241 mutex_unlock(&server->srv_mutex);241 cifs_server_unlock(server);
242 242
243 if (rc)243 if (rc)
244 return rc;244 return rc;
@@ -626,7 +626,7 @@ setup_ntlmv2_rsp(struct cifs_ses *ses, const struct nls_table *nls_cp) · 381 unmodified lines
626 626
627 memcpy(ses->auth_key.response + baselen, tiblob, tilen);627 memcpy(ses->auth_key.response + baselen, tiblob, tilen);
628 628
629 mutex_lock(&ses->server->srv_mutex);629 cifs_server_lock(ses->server);
630 630
631 rc = cifs_alloc_hash("hmac(md5)",631 rc = cifs_alloc_hash("hmac(md5)",
632 &ses->server->secmech.hmacmd5,632 &ses->server->secmech.hmacmd5,
@@ -678,7 +678,7 @@ setup_ntlmv2_rsp(struct cifs_ses *ses, const struct nls_table *nls_cp) · 45 unmodified lines
678 cifs_dbg(VFS, "%s: Could not generate md5 hash\n", __func__);678 cifs_dbg(VFS, "%s: Could not generate md5 hash\n", __func__);
679 679
680unlock:680unlock:
681 mutex_unlock(&ses->server->srv_mutex);681 cifs_server_unlock(ses->server);
682setup_ntlmv2_rsp_ret:682setup_ntlmv2_rsp_ret:
683 kfree(tiblob);683 kfree(tiblob);
684 684
fs/cifs/cifsglob.h+19−1
@@ -16,6 +16,7 @@ · 15 unmodified lines
16#include <linux/mempool.h>16#include <linux/mempool.h>
17#include <linux/workqueue.h>17#include <linux/workqueue.h>
18#include <linux/utsname.h>18#include <linux/utsname.h>
19#include <linux/sched/mm.h>
19#include <linux/netfs.h>20#include <linux/netfs.h>
20#include "cifs_fs_sb.h"21#include "cifs_fs_sb.h"
21#include "cifsacl.h"22#include "cifsacl.h"
@@ -628,7 +629,8 @@ struct TCP_Server_Info { · 606 unmodified lines
628 unsigned int in_flight; /* number of requests on the wire to server */629 unsigned int in_flight; /* number of requests on the wire to server */
629 unsigned int max_in_flight; /* max number of requests that were on wire */630 unsigned int max_in_flight; /* max number of requests that were on wire */
630 spinlock_t req_lock; /* protect the two values above */631 spinlock_t req_lock; /* protect the two values above */
631 struct mutex srv_mutex;632 struct mutex _srv_mutex;
633 unsigned int nofs_flag;
632 struct task_struct *tsk;634 struct task_struct *tsk;
633 char server_GUID[16];635 char server_GUID[16];
634 __u16 sec_mode;636 __u16 sec_mode;
@@ -743,6 +745,22 @@ struct TCP_Server_Info { · 108 unmodified lines
743#endif745#endif
744};746};
745 747
748static 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
756static 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
746struct cifs_credits {764struct cifs_credits {
747 unsigned int value;765 unsigned int value;
748 unsigned int instance;766 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
148 struct TCP_Server_Info *server = container_of(work,148 struct TCP_Server_Info *server = container_of(work,
149 struct TCP_Server_Info, resolve.work);149 struct TCP_Server_Info, resolve.work);
150 150
151 mutex_lock(&server->srv_mutex);151 cifs_server_lock(server);
152 152
153 /*153 /*
154 * Resolve the hostname again to make sure that IP address is up-to-date.154 * 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
159 __func__, rc);159 __func__, rc);
160 }160 }
161 161
162 mutex_unlock(&server->srv_mutex);162 cifs_server_unlock(server);
163}163}
164 164
165/*165/*
@@ -267,7 +267,7 @@ cifs_abort_connection(struct TCP_Server_Info *server) · 101 unmodified lines
267 267
268 /* do not want to be sending data on a socket we are freeing */268 /* do not want to be sending data on a socket we are freeing */
269 cifs_dbg(FYI, "%s: tearing down socket\n", __func__);269 cifs_dbg(FYI, "%s: tearing down socket\n", __func__);
270 mutex_lock(&server->srv_mutex);270 cifs_server_lock(server);
271 if (server->ssocket) {271 if (server->ssocket) {
272 cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n", server->ssocket->state,272 cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n", server->ssocket->state,
273 server->ssocket->flags);273 server->ssocket->flags);
@@ -296,7 +296,7 @@ cifs_abort_connection(struct TCP_Server_Info *server) · 22 unmodified lines
296 mid->mid_flags |= MID_DELETED;296 mid->mid_flags |= MID_DELETED;
297 }297 }
298 spin_unlock(&GlobalMid_Lock);298 spin_unlock(&GlobalMid_Lock);
299 mutex_unlock(&server->srv_mutex);299 cifs_server_unlock(server);
300 300
301 cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__);301 cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__);
302 list_for_each_entry_safe(mid, nmid, &retry_list, qhead) {302 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
306 }306 }
307 307
308 if (cifs_rdma_enabled(server)) {308 if (cifs_rdma_enabled(server)) {
309 mutex_lock(&server->srv_mutex);309 cifs_server_lock(server);
310 smbd_destroy(server);310 smbd_destroy(server);
311 mutex_unlock(&server->srv_mutex);311 cifs_server_unlock(server);
312 }312 }
313}313}
314 314
@@ -359,7 +359,7 @@ static int __cifs_reconnect(struct TCP_Server_Info *server, · 44 unmodified lines
359 359
360 do {360 do {
361 try_to_freeze();361 try_to_freeze();
362 mutex_lock(&server->srv_mutex);362 cifs_server_lock(server);
363 363
364 if (!cifs_swn_set_server_dstaddr(server)) {364 if (!cifs_swn_set_server_dstaddr(server)) {
365 /* resolve the hostname again to make sure that IP address is up-to-date */365 /* 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
372 else372 else
373 rc = generic_ip_connect(server);373 rc = generic_ip_connect(server);
374 if (rc) {374 if (rc) {
375 mutex_unlock(&server->srv_mutex);375 cifs_server_unlock(server);
376 cifs_dbg(FYI, "%s: reconnect error %d\n", __func__, rc);376 cifs_dbg(FYI, "%s: reconnect error %d\n", __func__, rc);
377 msleep(3000);377 msleep(3000);
378 } else {378 } else {
@@ -383,7 +383,7 @@ static int __cifs_reconnect(struct TCP_Server_Info *server, · 4 unmodified lines
383 server->tcpStatus = CifsNeedNegotiate;383 server->tcpStatus = CifsNeedNegotiate;
384 spin_unlock(&cifs_tcp_ses_lock);384 spin_unlock(&cifs_tcp_ses_lock);
385 cifs_swn_reset_server_dstaddr(server);385 cifs_swn_reset_server_dstaddr(server);
386 mutex_unlock(&server->srv_mutex);386 cifs_server_unlock(server);
387 mod_delayed_work(cifsiod_wq, &server->reconnect, 0);387 mod_delayed_work(cifsiod_wq, &server->reconnect, 0);
388 }388 }
389 } while (server->tcpStatus == CifsNeedReconnect);389 } while (server->tcpStatus == CifsNeedReconnect);
@@ -488,12 +488,12 @@ static int reconnect_dfs_server(struct TCP_Server_Info *server) · 98 unmodified lines
488 488
489 do {489 do {
490 try_to_freeze();490 try_to_freeze();
491 mutex_lock(&server->srv_mutex);491 cifs_server_lock(server);
492 492
493 rc = reconnect_target_unlocked(server, &tl, &target_hint);493 rc = reconnect_target_unlocked(server, &tl, &target_hint);
494 if (rc) {494 if (rc) {
495 /* Failed to reconnect socket */495 /* Failed to reconnect socket */
496 mutex_unlock(&server->srv_mutex);496 cifs_server_unlock(server);
497 cifs_dbg(FYI, "%s: reconnect error %d\n", __func__, rc);497 cifs_dbg(FYI, "%s: reconnect error %d\n", __func__, rc);
498 msleep(3000);498 msleep(3000);
499 continue;499 continue;
@@ -510,7 +510,7 @@ static int reconnect_dfs_server(struct TCP_Server_Info *server) · 10 unmodified lines
510 server->tcpStatus = CifsNeedNegotiate;510 server->tcpStatus = CifsNeedNegotiate;
511 spin_unlock(&cifs_tcp_ses_lock);511 spin_unlock(&cifs_tcp_ses_lock);
512 cifs_swn_reset_server_dstaddr(server);512 cifs_swn_reset_server_dstaddr(server);
513 mutex_unlock(&server->srv_mutex);513 cifs_server_unlock(server);
514 mod_delayed_work(cifsiod_wq, &server->reconnect, 0);514 mod_delayed_work(cifsiod_wq, &server->reconnect, 0);
515 } while (server->tcpStatus == CifsNeedReconnect);515 } while (server->tcpStatus == CifsNeedReconnect);
516 516
@@ -1565,7 +1565,7 @@ cifs_get_tcp_session(struct smb3_fs_context *ctx, · 1048 unmodified lines
1565 init_waitqueue_head(&tcp_ses->response_q);1565 init_waitqueue_head(&tcp_ses->response_q);
1566 init_waitqueue_head(&tcp_ses->request_q);1566 init_waitqueue_head(&tcp_ses->request_q);
1567 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);1567 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1568 mutex_init(&tcp_ses->srv_mutex);1568 mutex_init(&tcp_ses->_srv_mutex);
1569 memcpy(tcp_ses->workstation_RFC1001_name,1569 memcpy(tcp_ses->workstation_RFC1001_name,
1570 ctx->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);1570 ctx->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1571 memcpy(tcp_ses->server_RFC1001_name,1571 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
1327 cifs_dbg(VFS, "%s: failed to convert address \'%s\'. skip address matching.\n",1327 cifs_dbg(VFS, "%s: failed to convert address \'%s\'. skip address matching.\n",
1328 __func__, ip);1328 __func__, ip);
1329 } else {1329 } else {
1330 mutex_lock(&server->srv_mutex);1330 cifs_server_lock(server);
1331 match = cifs_match_ipaddr((struct sockaddr *)&server->dstaddr, &sa);1331 match = cifs_match_ipaddr((struct sockaddr *)&server->dstaddr, &sa);
1332 mutex_unlock(&server->srv_mutex);1332 cifs_server_unlock(server);
1333 }1333 }
1334 1334
1335 kfree(ip);1335 kfree(ip);
fs/cifs/sess.c+3−3
@@ -1120,14 +1120,14 @@ sess_establish_session(struct sess_data *sess_data) · 1119 unmodified lines
1120 struct cifs_ses *ses = sess_data->ses;1120 struct cifs_ses *ses = sess_data->ses;
1121 struct TCP_Server_Info *server = sess_data->server;1121 struct TCP_Server_Info *server = sess_data->server;
1122 1122
1123 mutex_lock(&server->srv_mutex);1123 cifs_server_lock(server);
1124 if (!server->session_estab) {1124 if (!server->session_estab) {
1125 if (server->sign) {1125 if (server->sign) {
1126 server->session_key.response =1126 server->session_key.response =
1127 kmemdup(ses->auth_key.response,1127 kmemdup(ses->auth_key.response,
1128 ses->auth_key.len, GFP_KERNEL);1128 ses->auth_key.len, GFP_KERNEL);
1129 if (!server->session_key.response) {1129 if (!server->session_key.response) {
1130 mutex_unlock(&server->srv_mutex);1130 cifs_server_unlock(server);
1131 return -ENOMEM;1131 return -ENOMEM;
1132 }1132 }
1133 server->session_key.len =1133 server->session_key.len =
@@ -1136,7 +1136,7 @@ sess_establish_session(struct sess_data *sess_data) · 2 unmodified lines
1136 server->sequence_number = 0x2;1136 server->sequence_number = 0x2;
1137 server->session_estab = true;1137 server->session_estab = true;
1138 }1138 }
1139 mutex_unlock(&server->srv_mutex);1139 cifs_server_unlock(server);
1140 1140
1141 cifs_dbg(FYI, "CIFS session established successfully\n");1141 cifs_dbg(FYI, "CIFS session established successfully\n");
1142 return 0;1142 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
38 in_buf->WordCount = 0;38 in_buf->WordCount = 0;
39 put_bcc(0, in_buf);39 put_bcc(0, in_buf);
40 40
41 mutex_lock(&server->srv_mutex);41 cifs_server_lock(server);
42 rc = cifs_sign_smb(in_buf, server, &mid->sequence_number);42 rc = cifs_sign_smb(in_buf, server, &mid->sequence_number);
43 if (rc) {43 if (rc) {
44 mutex_unlock(&server->srv_mutex);44 cifs_server_unlock(server);
45 return rc;45 return rc;
46 }46 }
47 47
@@ -55,7 +55,7 @@ send_nt_cancel(struct TCP_Server_Info *server, struct smb_rqst *rqst, · 7 unmodified lines
55 if (rc < 0)55 if (rc < 0)
56 server->sequence_number--;56 server->sequence_number--;
57 57
58 mutex_unlock(&server->srv_mutex);58 cifs_server_unlock(server);
59 59
60 cifs_dbg(FYI, "issued NT_CANCEL for mid %u, rc = %d\n",60 cifs_dbg(FYI, "issued NT_CANCEL for mid %u, rc = %d\n",
61 get_mid(in_buf), rc);61 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
1369 struct cifs_ses *ses = sess_data->ses;1369 struct cifs_ses *ses = sess_data->ses;
1370 struct TCP_Server_Info *server = sess_data->server;1370 struct TCP_Server_Info *server = sess_data->server;
1371 1371
1372 mutex_lock(&server->srv_mutex);1372 cifs_server_lock(server);
1373 if (server->ops->generate_signingkey) {1373 if (server->ops->generate_signingkey) {
1374 rc = server->ops->generate_signingkey(ses, server);1374 rc = server->ops->generate_signingkey(ses, server);
1375 if (rc) {1375 if (rc) {
1376 cifs_dbg(FYI,1376 cifs_dbg(FYI,
1377 "SMB3 session key generation failed\n");1377 "SMB3 session key generation failed\n");
1378 mutex_unlock(&server->srv_mutex);1378 cifs_server_unlock(server);
1379 return rc;1379 return rc;
1380 }1380 }
1381 }1381 }
@@ -1383,7 +1383,7 @@ SMB2_sess_establish_session(struct SMB2_sess_data *sess_data) · 1 unmodified line
1383 server->sequence_number = 0x2;1383 server->sequence_number = 0x2;
1384 server->session_estab = true;1384 server->session_estab = true;
1385 }1385 }
1386 mutex_unlock(&server->srv_mutex);1386 cifs_server_unlock(server);
1387 1387
1388 cifs_dbg(FYI, "SMB2/3 session established successfully\n");1388 cifs_dbg(FYI, "SMB2/3 session established successfully\n");
1389 return rc;1389 return rc;
fs/cifs/smbdirect.c+2−2
@@ -1382,9 +1382,9 @@ void smbd_destroy(struct TCP_Server_Info *server) · 1381 unmodified lines
1382 log_rdma_event(INFO, "freeing mr list\n");1382 log_rdma_event(INFO, "freeing mr list\n");
1383 wake_up_interruptible_all(&info->wait_mr);1383 wake_up_interruptible_all(&info->wait_mr);
1384 while (atomic_read(&info->mr_used_count)) {1384 while (atomic_read(&info->mr_used_count)) {
1385 mutex_unlock(&server->srv_mutex);1385 cifs_server_unlock(server);
1386 msleep(1000);1386 msleep(1000);
1387 mutex_lock(&server->srv_mutex);1387 cifs_server_lock(server);
1388 }1388 }
1389 destroy_mr_list(info);1389 destroy_mr_list(info);
1390 1390
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
822 } else822 } else
823 instance = exist_credits->instance;823 instance = exist_credits->instance;
824 824
825 mutex_lock(&server->srv_mutex);825 cifs_server_lock(server);
826 826
827 /*827 /*
828 * We can't use credits obtained from the previous session to send this828 * 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
830 * return -EAGAIN in such cases to let callers handle it.830 * return -EAGAIN in such cases to let callers handle it.
831 */831 */
832 if (instance != server->reconnect_instance) {832 if (instance != server->reconnect_instance) {
833 mutex_unlock(&server->srv_mutex);833 cifs_server_unlock(server);
834 add_credits_and_wake_if(server, &credits, optype);834 add_credits_and_wake_if(server, &credits, optype);
835 return -EAGAIN;835 return -EAGAIN;
836 }836 }
837 837
838 mid = server->ops->setup_async_request(server, rqst);838 mid = server->ops->setup_async_request(server, rqst);
839 if (IS_ERR(mid)) {839 if (IS_ERR(mid)) {
840 mutex_unlock(&server->srv_mutex);840 cifs_server_unlock(server);
841 add_credits_and_wake_if(server, &credits, optype);841 add_credits_and_wake_if(server, &credits, optype);
842 return PTR_ERR(mid);842 return PTR_ERR(mid);
843 }843 }
@@ -868,7 +868,7 @@ cifs_call_async(struct TCP_Server_Info *server, struct smb_rqst *rqst, · 24 unmodified lines
868 cifs_delete_mid(mid);868 cifs_delete_mid(mid);
869 }869 }
870 870
871 mutex_unlock(&server->srv_mutex);871 cifs_server_unlock(server);
872 872
873 if (rc == 0)873 if (rc == 0)
874 return 0;874 return 0;
@@ -1109,7 +1109,7 @@ compound_send_recv(const unsigned int xid, struct cifs_ses *ses, · 234 unmodified lines
1109 * of smb data.1109 * of smb data.
1110 */1110 */
1111 1111
1112 mutex_lock(&server->srv_mutex);1112 cifs_server_lock(server);
1113 1113
1114 /*1114 /*
1115 * All the parts of the compound chain belong obtained credits from the1115 * 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
1119 * handle it.1119 * handle it.
1120 */1120 */
1121 if (instance != server->reconnect_instance) {1121 if (instance != server->reconnect_instance) {
1122 mutex_unlock(&server->srv_mutex);1122 cifs_server_unlock(server);
1123 for (j = 0; j < num_rqst; j++)1123 for (j = 0; j < num_rqst; j++)
1124 add_credits(server, &credits[j], optype);1124 add_credits(server, &credits[j], optype);
1125 return -EAGAIN;1125 return -EAGAIN;
@@ -1131,7 +1131,7 @@ compound_send_recv(const unsigned int xid, struct cifs_ses *ses, · 5 unmodified lines
1131 revert_current_mid(server, i);1131 revert_current_mid(server, i);
1132 for (j = 0; j < i; j++)1132 for (j = 0; j < i; j++)
1133 cifs_delete_mid(midQ[j]);1133 cifs_delete_mid(midQ[j]);
1134 mutex_unlock(&server->srv_mutex);1134 cifs_server_unlock(server);
1135 1135
1136 /* Update # of requests on wire to server */1136 /* Update # of requests on wire to server */
1137 for (j = 0; j < num_rqst; j++)1137 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
1163 server->sequence_number -= 2;1163 server->sequence_number -= 2;
1164 }1164 }
1165 1165
1166 mutex_unlock(&server->srv_mutex);1166 cifs_server_unlock(server);
1167 1167
1168 /*1168 /*
1169 * If sending failed for some reason or it is an oplock break that we1169 * 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
1190 if ((ses->ses_status == SES_NEW) || (optype & CIFS_NEG_OP) || (optype & CIFS_SESS_OP)) {1190 if ((ses->ses_status == SES_NEW) || (optype & CIFS_NEG_OP) || (optype & CIFS_SESS_OP)) {
1191 spin_unlock(&cifs_tcp_ses_lock);1191 spin_unlock(&cifs_tcp_ses_lock);
1192 1192
1193 mutex_lock(&server->srv_mutex);1193 cifs_server_lock(server);
1194 smb311_update_preauth_hash(ses, server, rqst[0].rq_iov, rqst[0].rq_nvec);1194 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);
1196 1196
1197 spin_lock(&cifs_tcp_ses_lock);1197 spin_lock(&cifs_tcp_ses_lock);
1198 }1198 }
@@ -1266,9 +1266,9 @@ compound_send_recv(const unsigned int xid, struct cifs_ses *ses, · 67 unmodified lines
1266 .iov_len = resp_iov[0].iov_len1266 .iov_len = resp_iov[0].iov_len
1267 };1267 };
1268 spin_unlock(&cifs_tcp_ses_lock);1268 spin_unlock(&cifs_tcp_ses_lock);
1269 mutex_lock(&server->srv_mutex);1269 cifs_server_lock(server);
1270 smb311_update_preauth_hash(ses, server, &iov, 1);1270 smb311_update_preauth_hash(ses, server, &iov, 1);
1271 mutex_unlock(&server->srv_mutex);1271 cifs_server_unlock(server);
1272 spin_lock(&cifs_tcp_ses_lock);1272 spin_lock(&cifs_tcp_ses_lock);
1273 }1273 }
1274 spin_unlock(&cifs_tcp_ses_lock);1274 spin_unlock(&cifs_tcp_ses_lock);
@@ -1385,11 +1385,11 @@ SendReceive(const unsigned int xid, struct cifs_ses *ses, · 110 unmodified lines
1385 and avoid races inside tcp sendmsg code that could cause corruption1385 and avoid races inside tcp sendmsg code that could cause corruption
1386 of smb data */1386 of smb data */
1387 1387
1388 mutex_lock(&server->srv_mutex);1388 cifs_server_lock(server);
1389 1389
1390 rc = allocate_mid(ses, in_buf, &midQ);1390 rc = allocate_mid(ses, in_buf, &midQ);
1391 if (rc) {1391 if (rc) {
1392 mutex_unlock(&server->srv_mutex);1392 cifs_server_unlock(server);
1393 /* Update # of requests on wire to server */1393 /* Update # of requests on wire to server */
1394 add_credits(server, &credits, 0);1394 add_credits(server, &credits, 0);
1395 return rc;1395 return rc;
@@ -1397,7 +1397,7 @@ SendReceive(const unsigned int xid, struct cifs_ses *ses, · 1 unmodified line
1397 1397
1398 rc = cifs_sign_smb(in_buf, server, &midQ->sequence_number);1398 rc = cifs_sign_smb(in_buf, server, &midQ->sequence_number);
1399 if (rc) {1399 if (rc) {
1400 mutex_unlock(&server->srv_mutex);1400 cifs_server_unlock(server);
1401 goto out;1401 goto out;
1402 }1402 }
1403 1403
@@ -1411,7 +1411,7 @@ SendReceive(const unsigned int xid, struct cifs_ses *ses, · 7 unmodified lines
1411 if (rc < 0)1411 if (rc < 0)
1412 server->sequence_number -= 2;1412 server->sequence_number -= 2;
1413 1413
1414 mutex_unlock(&server->srv_mutex);1414 cifs_server_unlock(server);
1415 1415
1416 if (rc < 0)1416 if (rc < 0)
1417 goto out;1417 goto out;
@@ -1530,18 +1530,18 @@ SendReceiveBlockingLock(const unsigned int xid, struct cifs_tcon *tcon, · 112 unmodified lines
1530 and avoid races inside tcp sendmsg code that could cause corruption1530 and avoid races inside tcp sendmsg code that could cause corruption
1531 of smb data */1531 of smb data */
1532 1532
1533 mutex_lock(&server->srv_mutex);1533 cifs_server_lock(server);
1534 1534
1535 rc = allocate_mid(ses, in_buf, &midQ);1535 rc = allocate_mid(ses, in_buf, &midQ);
1536 if (rc) {1536 if (rc) {
1537 mutex_unlock(&server->srv_mutex);1537 cifs_server_unlock(server);
1538 return rc;1538 return rc;
1539 }1539 }
1540 1540
1541 rc = cifs_sign_smb(in_buf, server, &midQ->sequence_number);1541 rc = cifs_sign_smb(in_buf, server, &midQ->sequence_number);
1542 if (rc) {1542 if (rc) {
1543 cifs_delete_mid(midQ);1543 cifs_delete_mid(midQ);
1544 mutex_unlock(&server->srv_mutex);1544 cifs_server_unlock(server);
1545 return rc;1545 return rc;
1546 }1546 }
1547 1547
@@ -1554,7 +1554,7 @@ SendReceiveBlockingLock(const unsigned int xid, struct cifs_tcon *tcon, · 6 unmodified lines
1554 if (rc < 0)1554 if (rc < 0)
1555 server->sequence_number -= 2;1555 server->sequence_number -= 2;
1556 1556
1557 mutex_unlock(&server->srv_mutex);1557 cifs_server_unlock(server);
1558 1558
1559 if (rc < 0) {1559 if (rc < 0) {
1560 cifs_delete_mid(midQ);1560 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