Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag '5.19-rc-smb3-client-fixes-part2' of git://git.samba.org/sfrench/cifs-2.6
Pull cifs client fixes from Steve French:
"Nine cifs/smb3 client fixes.
Includes DFS fixes, some cleanup of leagcy SMB1 code, duplicated
message cleanup and a double free and deadlock fix"
* tag '5.19-rc-smb3-client-fixes-part2' of git://git.samba.org/sfrench/cifs-2.6:
cifs: fix uninitialized pointer in error case in dfs_cache_get_tgt_share
cifs: skip trailing separators of prefix paths
cifs: update internal module number
cifs: version operations for smb20 unneeded when legacy support disabled
cifs: do not build smb1ops if legacy support is disabled
cifs: fix potential deadlock in direct reclaim
cifs: when extending a file with falloc we should make files not-sparse
cifs: remove repeated debug message on cifs_put_smb_ses()
cifs: fix potential double free during failed mount
+143
-100
+3
-1
fs/cifs/Makefile
+3
-1
fs/cifs/Makefile
···
8
8
cifs-y := trace.o cifsfs.o cifssmb.o cifs_debug.o connect.o dir.o file.o \
9
9
inode.o link.o misc.o netmisc.o smbencrypt.o transport.o \
10
10
cifs_unicode.o nterr.o cifsencrypt.o \
11
-
readdir.o ioctl.o sess.o export.o smb1ops.o unc.o winucase.o \
11
+
readdir.o ioctl.o sess.o export.o unc.o winucase.o \
12
12
smb2ops.o smb2maperror.o smb2transport.o \
13
13
smb2misc.o smb2pdu.o smb2inode.o smb2file.o cifsacl.o fs_context.o \
14
14
dns_resolve.o cifs_spnego_negtokeninit.asn1.o asn1.o
···
30
30
cifs-$(CONFIG_CIFS_SMB_DIRECT) += smbdirect.o
31
31
32
32
cifs-$(CONFIG_CIFS_ROOT) += cifsroot.o
33
+
34
+
cifs-$(CONFIG_CIFS_ALLOW_INSECURE_LEGACY) += smb1ops.o
+2
-2
fs/cifs/cifs_swn.c
+2
-2
fs/cifs/cifs_swn.c
···
465
465
int ret = 0;
466
466
467
467
/* Store the reconnect address */
468
-
mutex_lock(&tcon->ses->server->srv_mutex);
468
+
cifs_server_lock(tcon->ses->server);
469
469
if (cifs_sockaddr_equal(&tcon->ses->server->dstaddr, addr))
470
470
goto unlock;
471
471
···
501
501
cifs_signal_cifsd_for_reconnect(tcon->ses->server, false);
502
502
503
503
unlock:
504
-
mutex_unlock(&tcon->ses->server->srv_mutex);
504
+
cifs_server_unlock(tcon->ses->server);
505
505
506
506
return ret;
507
507
}
+4
-4
fs/cifs/cifsencrypt.c
+4
-4
fs/cifs/cifsencrypt.c
···
236
236
cpu_to_le32(expected_sequence_number);
237
237
cifs_pdu->Signature.Sequence.Reserved = 0;
238
238
239
-
mutex_lock(&server->srv_mutex);
239
+
cifs_server_lock(server);
240
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
243
if (rc)
244
244
return rc;
···
626
626
627
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
631
rc = cifs_alloc_hash("hmac(md5)",
632
632
&ses->server->secmech.hmacmd5,
···
678
678
cifs_dbg(VFS, "%s: Could not generate md5 hash\n", __func__);
679
679
680
680
unlock:
681
-
mutex_unlock(&ses->server->srv_mutex);
681
+
cifs_server_unlock(ses->server);
682
682
setup_ntlmv2_rsp_ret:
683
683
kfree(tiblob);
684
684
+6
-4
fs/cifs/cifsfs.c
+6
-4
fs/cifs/cifsfs.c
···
838
838
int flags, struct smb3_fs_context *old_ctx)
839
839
{
840
840
int rc;
841
-
struct super_block *sb;
841
+
struct super_block *sb = NULL;
842
842
struct cifs_sb_info *cifs_sb = NULL;
843
843
struct cifs_mnt_data mnt_data;
844
844
struct dentry *root;
···
934
934
return root;
935
935
out:
936
936
if (cifs_sb) {
937
-
kfree(cifs_sb->prepath);
938
-
smb3_cleanup_fs_context(cifs_sb->ctx);
939
-
kfree(cifs_sb);
937
+
if (!sb || IS_ERR(sb)) { /* otherwise kill_sb will handle */
938
+
kfree(cifs_sb->prepath);
939
+
smb3_cleanup_fs_context(cifs_sb->ctx);
940
+
kfree(cifs_sb);
941
+
}
940
942
}
941
943
return root;
942
944
}
+3
-2
fs/cifs/cifsfs.h
+3
-2
fs/cifs/cifsfs.h
···
152
152
extern const struct export_operations cifs_export_ops;
153
153
#endif /* CONFIG_CIFS_NFSD_EXPORT */
154
154
155
-
#define SMB3_PRODUCT_BUILD 35
156
-
#define CIFS_VERSION "2.36"
155
+
/* when changing internal version - update following two lines at same time */
156
+
#define SMB3_PRODUCT_BUILD 37
157
+
#define CIFS_VERSION "2.37"
157
158
#endif /* _CIFSFS_H */
+22
-2
fs/cifs/cifsglob.h
+22
-2
fs/cifs/cifsglob.h
···
16
16
#include <linux/mempool.h>
17
17
#include <linux/workqueue.h>
18
18
#include <linux/utsname.h>
19
+
#include <linux/sched/mm.h>
19
20
#include <linux/netfs.h>
20
21
#include "cifs_fs_sb.h"
21
22
#include "cifsacl.h"
···
629
628
unsigned int in_flight; /* number of requests on the wire to server */
630
629
unsigned int max_in_flight; /* max number of requests that were on wire */
631
630
spinlock_t req_lock; /* protect the two values above */
632
-
struct mutex srv_mutex;
631
+
struct mutex _srv_mutex;
632
+
unsigned int nofs_flag;
633
633
struct task_struct *tsk;
634
634
char server_GUID[16];
635
635
__u16 sec_mode;
···
744
742
char *origin_fullpath, *leaf_fullpath, *current_fullpath;
745
743
#endif
746
744
};
745
+
746
+
static inline void cifs_server_lock(struct TCP_Server_Info *server)
747
+
{
748
+
unsigned int nofs_flag = memalloc_nofs_save();
749
+
750
+
mutex_lock(&server->_srv_mutex);
751
+
server->nofs_flag = nofs_flag;
752
+
}
753
+
754
+
static inline void cifs_server_unlock(struct TCP_Server_Info *server)
755
+
{
756
+
unsigned int nofs_flag = server->nofs_flag;
757
+
758
+
mutex_unlock(&server->_srv_mutex);
759
+
memalloc_nofs_restore(nofs_flag);
760
+
}
747
761
748
762
struct cifs_credits {
749
763
unsigned int value;
···
1963
1945
1964
1946
/* Operations for different SMB versions */
1965
1947
#define SMB1_VERSION_STRING "1.0"
1948
+
#define SMB20_VERSION_STRING "2.0"
1949
+
#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1966
1950
extern struct smb_version_operations smb1_operations;
1967
1951
extern struct smb_version_values smb1_values;
1968
-
#define SMB20_VERSION_STRING "2.0"
1969
1952
extern struct smb_version_operations smb20_operations;
1970
1953
extern struct smb_version_values smb20_values;
1954
+
#endif /* CIFS_ALLOW_INSECURE_LEGACY */
1971
1955
#define SMB21_VERSION_STRING "2.1"
1972
1956
extern struct smb_version_operations smb21_operations;
1973
1957
extern struct smb_version_values smb21_values;
+13
-14
fs/cifs/connect.c
+13
-14
fs/cifs/connect.c
···
148
148
struct TCP_Server_Info *server = container_of(work,
149
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
154
* Resolve the hostname again to make sure that IP address is up-to-date.
···
159
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
267
268
268
/* do not want to be sending data on a socket we are freeing */
269
269
cifs_dbg(FYI, "%s: tearing down socket\n", __func__);
270
-
mutex_lock(&server->srv_mutex);
270
+
cifs_server_lock(server);
271
271
if (server->ssocket) {
272
272
cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n", server->ssocket->state,
273
273
server->ssocket->flags);
···
296
296
mid->mid_flags |= MID_DELETED;
297
297
}
298
298
spin_unlock(&GlobalMid_Lock);
299
-
mutex_unlock(&server->srv_mutex);
299
+
cifs_server_unlock(server);
300
300
301
301
cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__);
302
302
list_for_each_entry_safe(mid, nmid, &retry_list, qhead) {
···
306
306
}
307
307
308
308
if (cifs_rdma_enabled(server)) {
309
-
mutex_lock(&server->srv_mutex);
309
+
cifs_server_lock(server);
310
310
smbd_destroy(server);
311
-
mutex_unlock(&server->srv_mutex);
311
+
cifs_server_unlock(server);
312
312
}
313
313
}
314
314
···
359
359
360
360
do {
361
361
try_to_freeze();
362
-
mutex_lock(&server->srv_mutex);
362
+
cifs_server_lock(server);
363
363
364
364
if (!cifs_swn_set_server_dstaddr(server)) {
365
365
/* resolve the hostname again to make sure that IP address is up-to-date */
···
372
372
else
373
373
rc = generic_ip_connect(server);
374
374
if (rc) {
375
-
mutex_unlock(&server->srv_mutex);
375
+
cifs_server_unlock(server);
376
376
cifs_dbg(FYI, "%s: reconnect error %d\n", __func__, rc);
377
377
msleep(3000);
378
378
} else {
···
383
383
server->tcpStatus = CifsNeedNegotiate;
384
384
spin_unlock(&cifs_tcp_ses_lock);
385
385
cifs_swn_reset_server_dstaddr(server);
386
-
mutex_unlock(&server->srv_mutex);
386
+
cifs_server_unlock(server);
387
387
mod_delayed_work(cifsiod_wq, &server->reconnect, 0);
388
388
}
389
389
} while (server->tcpStatus == CifsNeedReconnect);
···
488
488
489
489
do {
490
490
try_to_freeze();
491
-
mutex_lock(&server->srv_mutex);
491
+
cifs_server_lock(server);
492
492
493
493
rc = reconnect_target_unlocked(server, &tl, &target_hint);
494
494
if (rc) {
495
495
/* Failed to reconnect socket */
496
-
mutex_unlock(&server->srv_mutex);
496
+
cifs_server_unlock(server);
497
497
cifs_dbg(FYI, "%s: reconnect error %d\n", __func__, rc);
498
498
msleep(3000);
499
499
continue;
···
510
510
server->tcpStatus = CifsNeedNegotiate;
511
511
spin_unlock(&cifs_tcp_ses_lock);
512
512
cifs_swn_reset_server_dstaddr(server);
513
-
mutex_unlock(&server->srv_mutex);
513
+
cifs_server_unlock(server);
514
514
mod_delayed_work(cifsiod_wq, &server->reconnect, 0);
515
515
} while (server->tcpStatus == CifsNeedReconnect);
516
516
···
1565
1565
init_waitqueue_head(&tcp_ses->response_q);
1566
1566
init_waitqueue_head(&tcp_ses->request_q);
1567
1567
INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1568
-
mutex_init(&tcp_ses->srv_mutex);
1568
+
mutex_init(&tcp_ses->_srv_mutex);
1569
1569
memcpy(tcp_ses->workstation_RFC1001_name,
1570
1570
ctx->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1571
1571
memcpy(tcp_ses->server_RFC1001_name,
···
1845
1845
unsigned int rc, xid;
1846
1846
unsigned int chan_count;
1847
1847
struct TCP_Server_Info *server = ses->server;
1848
-
cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
1849
1848
1850
1849
spin_lock(&cifs_tcp_ses_lock);
1851
1850
if (ses->ses_status == SES_EXITING) {
+52
-38
fs/cifs/dfs_cache.c
+52
-38
fs/cifs/dfs_cache.c
···
1229
1229
kref_put(&mg->refcount, mount_group_release);
1230
1230
}
1231
1231
1232
+
/* Extract share from DFS target and return a pointer to prefix path or NULL */
1233
+
static const char *parse_target_share(const char *target, char **share)
1234
+
{
1235
+
const char *s, *seps = "/\\";
1236
+
size_t len;
1237
+
1238
+
s = strpbrk(target + 1, seps);
1239
+
if (!s)
1240
+
return ERR_PTR(-EINVAL);
1241
+
1242
+
len = strcspn(s + 1, seps);
1243
+
if (!len)
1244
+
return ERR_PTR(-EINVAL);
1245
+
s += len;
1246
+
1247
+
len = s - target + 1;
1248
+
*share = kstrndup(target, len, GFP_KERNEL);
1249
+
if (!*share)
1250
+
return ERR_PTR(-ENOMEM);
1251
+
1252
+
s = target + len;
1253
+
return s + strspn(s, seps);
1254
+
}
1255
+
1232
1256
/**
1233
1257
* dfs_cache_get_tgt_share - parse a DFS target
1234
1258
*
···
1266
1242
int dfs_cache_get_tgt_share(char *path, const struct dfs_cache_tgt_iterator *it, char **share,
1267
1243
char **prefix)
1268
1244
{
1269
-
char *s, sep, *p;
1270
-
size_t len;
1271
-
size_t plen1, plen2;
1245
+
char sep;
1246
+
char *target_share;
1247
+
char *ppath = NULL;
1248
+
const char *target_ppath, *dfsref_ppath;
1249
+
size_t target_pplen, dfsref_pplen;
1250
+
size_t len, c;
1272
1251
1273
1252
if (!it || !path || !share || !prefix || strlen(path) < it->it_path_consumed)
1274
1253
return -EINVAL;
1275
-
1276
-
*share = NULL;
1277
-
*prefix = NULL;
1278
1254
1279
1255
sep = it->it_name[0];
1280
1256
if (sep != '\\' && sep != '/')
1281
1257
return -EINVAL;
1282
1258
1283
-
s = strchr(it->it_name + 1, sep);
1284
-
if (!s)
1285
-
return -EINVAL;
1259
+
target_ppath = parse_target_share(it->it_name, &target_share);
1260
+
if (IS_ERR(target_ppath))
1261
+
return PTR_ERR(target_ppath);
1286
1262
1287
-
/* point to prefix in target node */
1288
-
s = strchrnul(s + 1, sep);
1263
+
/* point to prefix in DFS referral path */
1264
+
dfsref_ppath = path + it->it_path_consumed;
1265
+
dfsref_ppath += strspn(dfsref_ppath, "/\\");
1289
1266
1290
-
/* extract target share */
1291
-
*share = kstrndup(it->it_name, s - it->it_name, GFP_KERNEL);
1292
-
if (!*share)
1293
-
return -ENOMEM;
1267
+
target_pplen = strlen(target_ppath);
1268
+
dfsref_pplen = strlen(dfsref_ppath);
1294
1269
1295
-
/* skip separator */
1296
-
if (*s)
1297
-
s++;
1298
-
/* point to prefix in DFS path */
1299
-
p = path + it->it_path_consumed;
1300
-
if (*p == sep)
1301
-
p++;
1302
-
1303
-
/* merge prefix paths from DFS path and target node */
1304
-
plen1 = it->it_name + strlen(it->it_name) - s;
1305
-
plen2 = path + strlen(path) - p;
1306
-
if (plen1 || plen2) {
1307
-
len = plen1 + plen2 + 2;
1308
-
*prefix = kmalloc(len, GFP_KERNEL);
1309
-
if (!*prefix) {
1310
-
kfree(*share);
1311
-
*share = NULL;
1270
+
/* merge prefix paths from DFS referral path and target node */
1271
+
if (target_pplen || dfsref_pplen) {
1272
+
len = target_pplen + dfsref_pplen + 2;
1273
+
ppath = kzalloc(len, GFP_KERNEL);
1274
+
if (!ppath) {
1275
+
kfree(target_share);
1312
1276
return -ENOMEM;
1313
1277
}
1314
-
if (plen1)
1315
-
scnprintf(*prefix, len, "%.*s%c%.*s", (int)plen1, s, sep, (int)plen2, p);
1316
-
else
1317
-
strscpy(*prefix, p, len);
1278
+
c = strscpy(ppath, target_ppath, len);
1279
+
if (c && dfsref_pplen)
1280
+
ppath[c] = sep;
1281
+
strlcat(ppath, dfsref_ppath, len);
1318
1282
}
1283
+
*share = target_share;
1284
+
*prefix = ppath;
1319
1285
return 0;
1320
1286
}
1321
1287
···
1341
1327
cifs_dbg(VFS, "%s: failed to convert address \'%s\'. skip address matching.\n",
1342
1328
__func__, ip);
1343
1329
} else {
1344
-
mutex_lock(&server->srv_mutex);
1330
+
cifs_server_lock(server);
1345
1331
match = cifs_match_ipaddr((struct sockaddr *)&server->dstaddr, &sa);
1346
-
mutex_unlock(&server->srv_mutex);
1332
+
cifs_server_unlock(server);
1347
1333
}
1348
1334
1349
1335
kfree(ip);
+3
-3
fs/cifs/sess.c
+3
-3
fs/cifs/sess.c
···
1120
1120
struct cifs_ses *ses = sess_data->ses;
1121
1121
struct TCP_Server_Info *server = sess_data->server;
1122
1122
1123
-
mutex_lock(&server->srv_mutex);
1123
+
cifs_server_lock(server);
1124
1124
if (!server->session_estab) {
1125
1125
if (server->sign) {
1126
1126
server->session_key.response =
1127
1127
kmemdup(ses->auth_key.response,
1128
1128
ses->auth_key.len, GFP_KERNEL);
1129
1129
if (!server->session_key.response) {
1130
-
mutex_unlock(&server->srv_mutex);
1130
+
cifs_server_unlock(server);
1131
1131
return -ENOMEM;
1132
1132
}
1133
1133
server->session_key.len =
···
1136
1136
server->sequence_number = 0x2;
1137
1137
server->session_estab = true;
1138
1138
}
1139
-
mutex_unlock(&server->srv_mutex);
1139
+
cifs_server_unlock(server);
1140
1140
1141
1141
cifs_dbg(FYI, "CIFS session established successfully\n");
1142
1142
return 0;
+3
-3
fs/cifs/smb1ops.c
+3
-3
fs/cifs/smb1ops.c
···
38
38
in_buf->WordCount = 0;
39
39
put_bcc(0, in_buf);
40
40
41
-
mutex_lock(&server->srv_mutex);
41
+
cifs_server_lock(server);
42
42
rc = cifs_sign_smb(in_buf, server, &mid->sequence_number);
43
43
if (rc) {
44
-
mutex_unlock(&server->srv_mutex);
44
+
cifs_server_unlock(server);
45
45
return rc;
46
46
}
47
47
···
55
55
if (rc < 0)
56
56
server->sequence_number--;
57
57
58
-
mutex_unlock(&server->srv_mutex);
58
+
cifs_server_unlock(server);
59
59
60
60
cifs_dbg(FYI, "issued NT_CANCEL for mid %u, rc = %d\n",
61
61
get_mid(in_buf), rc);
+7
-2
fs/cifs/smb2ops.c
+7
-2
fs/cifs/smb2ops.c
···
3859
3859
if (rc)
3860
3860
goto out;
3861
3861
3862
-
if ((cifsi->cifsAttrs & FILE_ATTRIBUTE_SPARSE_FILE) == 0)
3862
+
if (cifsi->cifsAttrs & FILE_ATTRIBUTE_SPARSE_FILE)
3863
3863
smb2_set_sparse(xid, tcon, cfile, inode, false);
3864
3864
3865
3865
eof = cpu_to_le64(off + len);
···
4345
4345
}
4346
4346
}
4347
4347
4348
+
#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
4348
4349
static bool
4349
4350
smb2_is_read_op(__u32 oplock)
4350
4351
{
4351
4352
return oplock == SMB2_OPLOCK_LEVEL_II;
4352
4353
}
4354
+
#endif /* CIFS_ALLOW_INSECURE_LEGACY */
4353
4355
4354
4356
static bool
4355
4357
smb21_is_read_op(__u32 oplock)
···
5450
5448
return rc;
5451
5449
}
5452
5450
5453
-
5451
+
#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
5454
5452
struct smb_version_operations smb20_operations = {
5455
5453
.compare_fids = smb2_compare_fids,
5456
5454
.setup_request = smb2_setup_request,
···
5549
5547
.is_status_io_timeout = smb2_is_status_io_timeout,
5550
5548
.is_network_name_deleted = smb2_is_network_name_deleted,
5551
5549
};
5550
+
#endif /* CIFS_ALLOW_INSECURE_LEGACY */
5552
5551
5553
5552
struct smb_version_operations smb21_operations = {
5554
5553
.compare_fids = smb2_compare_fids,
···
5881
5878
.is_network_name_deleted = smb2_is_network_name_deleted,
5882
5879
};
5883
5880
5881
+
#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
5884
5882
struct smb_version_values smb20_values = {
5885
5883
.version_string = SMB20_VERSION_STRING,
5886
5884
.protocol_id = SMB20_PROT_ID,
···
5902
5898
.signing_required = SMB2_NEGOTIATE_SIGNING_REQUIRED,
5903
5899
.create_lease_size = sizeof(struct create_lease),
5904
5900
};
5901
+
#endif /* ALLOW_INSECURE_LEGACY */
5905
5902
5906
5903
struct smb_version_values smb21_values = {
5907
5904
.version_string = SMB21_VERSION_STRING,
+3
-3
fs/cifs/smb2pdu.c
+3
-3
fs/cifs/smb2pdu.c
···
1369
1369
struct cifs_ses *ses = sess_data->ses;
1370
1370
struct TCP_Server_Info *server = sess_data->server;
1371
1371
1372
-
mutex_lock(&server->srv_mutex);
1372
+
cifs_server_lock(server);
1373
1373
if (server->ops->generate_signingkey) {
1374
1374
rc = server->ops->generate_signingkey(ses, server);
1375
1375
if (rc) {
1376
1376
cifs_dbg(FYI,
1377
1377
"SMB3 session key generation failed\n");
1378
-
mutex_unlock(&server->srv_mutex);
1378
+
cifs_server_unlock(server);
1379
1379
return rc;
1380
1380
}
1381
1381
}
···
1383
1383
server->sequence_number = 0x2;
1384
1384
server->session_estab = true;
1385
1385
}
1386
-
mutex_unlock(&server->srv_mutex);
1386
+
cifs_server_unlock(server);
1387
1387
1388
1388
cifs_dbg(FYI, "SMB2/3 session established successfully\n");
1389
1389
return rc;
+2
-2
fs/cifs/smbdirect.c
+2
-2
fs/cifs/smbdirect.c
···
1382
1382
log_rdma_event(INFO, "freeing mr list\n");
1383
1383
wake_up_interruptible_all(&info->wait_mr);
1384
1384
while (atomic_read(&info->mr_used_count)) {
1385
-
mutex_unlock(&server->srv_mutex);
1385
+
cifs_server_unlock(server);
1386
1386
msleep(1000);
1387
-
mutex_lock(&server->srv_mutex);
1387
+
cifs_server_lock(server);
1388
1388
}
1389
1389
destroy_mr_list(info);
1390
1390
+20
-20
fs/cifs/transport.c
+20
-20
fs/cifs/transport.c
···
822
822
} else
823
823
instance = exist_credits->instance;
824
824
825
-
mutex_lock(&server->srv_mutex);
825
+
cifs_server_lock(server);
826
826
827
827
/*
828
828
* We can't use credits obtained from the previous session to send this
···
830
830
* return -EAGAIN in such cases to let callers handle it.
831
831
*/
832
832
if (instance != server->reconnect_instance) {
833
-
mutex_unlock(&server->srv_mutex);
833
+
cifs_server_unlock(server);
834
834
add_credits_and_wake_if(server, &credits, optype);
835
835
return -EAGAIN;
836
836
}
837
837
838
838
mid = server->ops->setup_async_request(server, rqst);
839
839
if (IS_ERR(mid)) {
840
-
mutex_unlock(&server->srv_mutex);
840
+
cifs_server_unlock(server);
841
841
add_credits_and_wake_if(server, &credits, optype);
842
842
return PTR_ERR(mid);
843
843
}
···
868
868
cifs_delete_mid(mid);
869
869
}
870
870
871
-
mutex_unlock(&server->srv_mutex);
871
+
cifs_server_unlock(server);
872
872
873
873
if (rc == 0)
874
874
return 0;
···
1109
1109
* of smb data.
1110
1110
*/
1111
1111
1112
-
mutex_lock(&server->srv_mutex);
1112
+
cifs_server_lock(server);
1113
1113
1114
1114
/*
1115
1115
* All the parts of the compound chain belong obtained credits from the
···
1119
1119
* handle it.
1120
1120
*/
1121
1121
if (instance != server->reconnect_instance) {
1122
-
mutex_unlock(&server->srv_mutex);
1122
+
cifs_server_unlock(server);
1123
1123
for (j = 0; j < num_rqst; j++)
1124
1124
add_credits(server, &credits[j], optype);
1125
1125
return -EAGAIN;
···
1131
1131
revert_current_mid(server, i);
1132
1132
for (j = 0; j < i; j++)
1133
1133
cifs_delete_mid(midQ[j]);
1134
-
mutex_unlock(&server->srv_mutex);
1134
+
cifs_server_unlock(server);
1135
1135
1136
1136
/* Update # of requests on wire to server */
1137
1137
for (j = 0; j < num_rqst; j++)
···
1163
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
1169
* If sending failed for some reason or it is an oplock break that we
···
1190
1190
if ((ses->ses_status == SES_NEW) || (optype & CIFS_NEG_OP) || (optype & CIFS_SESS_OP)) {
1191
1191
spin_unlock(&cifs_tcp_ses_lock);
1192
1192
1193
-
mutex_lock(&server->srv_mutex);
1193
+
cifs_server_lock(server);
1194
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
1197
spin_lock(&cifs_tcp_ses_lock);
1198
1198
}
···
1266
1266
.iov_len = resp_iov[0].iov_len
1267
1267
};
1268
1268
spin_unlock(&cifs_tcp_ses_lock);
1269
-
mutex_lock(&server->srv_mutex);
1269
+
cifs_server_lock(server);
1270
1270
smb311_update_preauth_hash(ses, server, &iov, 1);
1271
-
mutex_unlock(&server->srv_mutex);
1271
+
cifs_server_unlock(server);
1272
1272
spin_lock(&cifs_tcp_ses_lock);
1273
1273
}
1274
1274
spin_unlock(&cifs_tcp_ses_lock);
···
1385
1385
and avoid races inside tcp sendmsg code that could cause corruption
1386
1386
of smb data */
1387
1387
1388
-
mutex_lock(&server->srv_mutex);
1388
+
cifs_server_lock(server);
1389
1389
1390
1390
rc = allocate_mid(ses, in_buf, &midQ);
1391
1391
if (rc) {
1392
-
mutex_unlock(&server->srv_mutex);
1392
+
cifs_server_unlock(server);
1393
1393
/* Update # of requests on wire to server */
1394
1394
add_credits(server, &credits, 0);
1395
1395
return rc;
···
1397
1397
1398
1398
rc = cifs_sign_smb(in_buf, server, &midQ->sequence_number);
1399
1399
if (rc) {
1400
-
mutex_unlock(&server->srv_mutex);
1400
+
cifs_server_unlock(server);
1401
1401
goto out;
1402
1402
}
1403
1403
···
1411
1411
if (rc < 0)
1412
1412
server->sequence_number -= 2;
1413
1413
1414
-
mutex_unlock(&server->srv_mutex);
1414
+
cifs_server_unlock(server);
1415
1415
1416
1416
if (rc < 0)
1417
1417
goto out;
···
1530
1530
and avoid races inside tcp sendmsg code that could cause corruption
1531
1531
of smb data */
1532
1532
1533
-
mutex_lock(&server->srv_mutex);
1533
+
cifs_server_lock(server);
1534
1534
1535
1535
rc = allocate_mid(ses, in_buf, &midQ);
1536
1536
if (rc) {
1537
-
mutex_unlock(&server->srv_mutex);
1537
+
cifs_server_unlock(server);
1538
1538
return rc;
1539
1539
}
1540
1540
1541
1541
rc = cifs_sign_smb(in_buf, server, &midQ->sequence_number);
1542
1542
if (rc) {
1543
1543
cifs_delete_mid(midQ);
1544
-
mutex_unlock(&server->srv_mutex);
1544
+
cifs_server_unlock(server);
1545
1545
return rc;
1546
1546
}
1547
1547
···
1554
1554
if (rc < 0)
1555
1555
server->sequence_number -= 2;
1556
1556
1557
-
mutex_unlock(&server->srv_mutex);
1557
+
cifs_server_unlock(server);
1558
1558
1559
1559
if (rc < 0) {
1560
1560
cifs_delete_mid(midQ);