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/
Unified · Split
| @@ -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 | ||
| 503 | unlock: | 503 | unlock: |
| 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 | } |
| @@ -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 | ||
| 680 | unlock: | 680 | unlock: |
| 681 | mutex_unlock(&ses->server->srv_mutex); | 681 | cifs_server_unlock(ses->server); |
| 682 | setup_ntlmv2_rsp_ret: | 682 | setup_ntlmv2_rsp_ret: |
| 683 | kfree(tiblob); | 683 | kfree(tiblob); |
| 684 | 684 | ||
| @@ -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 | #endif | 745 | #endif |
| 744 | }; | 746 | }; |
| 745 | 747 | ||
| 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 | |||
| 746 | struct cifs_credits { | 764 | struct cifs_credits { |
| 747 | unsigned int value; | 765 | unsigned int value; |
| 748 | unsigned int instance; | 766 | unsigned int instance; |
| @@ -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 | else | 372 | 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, |
| @@ -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); |
| @@ -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; |
| @@ -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); |
| @@ -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; |
| @@ -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 | ||
| @@ -822,7 +822,7 @@ cifs_call_async(struct TCP_Server_Info *server, struct smb_rqst *rqst, · 821 unmodified lines | |||
| 822 | } else | 822 | } 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 this | 828 | * 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 the | 1115 | * 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 we | 1169 | * 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_len | 1266 | .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 corruption | 1385 | 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 corruption | 1530 | 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); |