Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag '6.3-rc-smb3-client-fixes-part2' of git://git.samba.org/sfrench/cifs-2.6
Pull more cifs updates from Steve French:
- xfstest generic/208 fix (memory leak)
- minor netfs fix (to address smatch warning)
- a DFS fix for stable
- a reconnect race fix
- two multichannel fixes
- RDMA (smbdirect) fix
- two additional writeback fixes from David
* tag '6.3-rc-smb3-client-fixes-part2' of git://git.samba.org/sfrench/cifs-2.6:
cifs: Fix memory leak in direct I/O
cifs: prevent data race in cifs_reconnect_tcon()
cifs: improve checking of DFS links over STATUS_OBJECT_NAME_INVALID
iov: Fix netfs_extract_user_to_sg()
cifs: Fix cifs_write_back_from_locked_folio()
cifs: reuse cifs_match_ipaddr for comparison of dstaddr too
cifs: match even the scope id for ipv6 addresses
cifs: Fix an uninitialised variable
cifs: Add some missing xas_retry() calls
+190
-157
+16
-5
fs/cifs/cifsproto.h
+16
-5
fs/cifs/cifsproto.h
···
667
667
int match_target_ip(struct TCP_Server_Info *server,
668
668
const char *share, size_t share_len,
669
669
bool *result);
670
-
671
-
int cifs_dfs_query_info_nonascii_quirk(const unsigned int xid,
672
-
struct cifs_tcon *tcon,
673
-
struct cifs_sb_info *cifs_sb,
674
-
const char *dfs_link_path);
670
+
int cifs_inval_name_dfs_link_error(const unsigned int xid,
671
+
struct cifs_tcon *tcon,
672
+
struct cifs_sb_info *cifs_sb,
673
+
const char *full_path,
674
+
bool *islink);
675
+
#else
676
+
static inline int cifs_inval_name_dfs_link_error(const unsigned int xid,
677
+
struct cifs_tcon *tcon,
678
+
struct cifs_sb_info *cifs_sb,
679
+
const char *full_path,
680
+
bool *islink)
681
+
{
682
+
*islink = false;
683
+
return 0;
684
+
}
675
685
#endif
676
686
677
687
static inline int cifs_create_options(struct cifs_sb_info *cifs_sb, int options)
···
694
684
695
685
struct super_block *cifs_get_tcon_super(struct cifs_tcon *tcon);
696
686
void cifs_put_tcon_super(struct super_block *sb);
687
+
int cifs_wait_for_server_reconnect(struct TCP_Server_Info *server, bool retry);
697
688
698
689
#endif /* _CIFSPROTO_H */
+3
-40
fs/cifs/cifssmb.c
+3
-40
fs/cifs/cifssmb.c
···
72
72
struct cifs_ses *ses;
73
73
struct TCP_Server_Info *server;
74
74
struct nls_table *nls_codepage;
75
-
int retries;
76
75
77
76
/*
78
77
* SMBs NegProt, SessSetup, uLogoff do not have tcon yet so check for
···
101
102
}
102
103
spin_unlock(&tcon->tc_lock);
103
104
104
-
retries = server->nr_targets;
105
-
106
-
/*
107
-
* Give demultiplex thread up to 10 seconds to each target available for
108
-
* reconnect -- should be greater than cifs socket timeout which is 7
109
-
* seconds.
110
-
*/
111
-
while (server->tcpStatus == CifsNeedReconnect) {
112
-
rc = wait_event_interruptible_timeout(server->response_q,
113
-
(server->tcpStatus != CifsNeedReconnect),
114
-
10 * HZ);
115
-
if (rc < 0) {
116
-
cifs_dbg(FYI, "%s: aborting reconnect due to a received signal by the process\n",
117
-
__func__);
118
-
return -ERESTARTSYS;
119
-
}
120
-
121
-
/* are we still trying to reconnect? */
122
-
spin_lock(&server->srv_lock);
123
-
if (server->tcpStatus != CifsNeedReconnect) {
124
-
spin_unlock(&server->srv_lock);
125
-
break;
126
-
}
127
-
spin_unlock(&server->srv_lock);
128
-
129
-
if (retries && --retries)
130
-
continue;
131
-
132
-
/*
133
-
* on "soft" mounts we wait once. Hard mounts keep
134
-
* retrying until process is killed or server comes
135
-
* back on-line
136
-
*/
137
-
if (!tcon->retry) {
138
-
cifs_dbg(FYI, "gave up waiting on reconnect in smb_init\n");
139
-
return -EHOSTDOWN;
140
-
}
141
-
retries = server->nr_targets;
142
-
}
105
+
rc = cifs_wait_for_server_reconnect(server, tcon->retry);
106
+
if (rc)
107
+
return rc;
143
108
144
109
spin_lock(&ses->chan_lock);
145
110
if (!cifs_chan_needs_reconnect(ses, server) && !tcon->need_reconnect) {
+4
-27
fs/cifs/connect.c
+4
-27
fs/cifs/connect.c
···
1294
1294
case AF_INET6: {
1295
1295
struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1296
1296
struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
1297
-
return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1297
+
return (ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr)
1298
+
&& saddr6->sin6_scope_id == vaddr6->sin6_scope_id);
1298
1299
}
1299
1300
default:
1300
1301
WARN_ON(1);
···
1344
1343
1345
1344
static bool match_server_address(struct TCP_Server_Info *server, struct sockaddr *addr)
1346
1345
{
1347
-
switch (addr->sa_family) {
1348
-
case AF_INET: {
1349
-
struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1350
-
struct sockaddr_in *srv_addr4 =
1351
-
(struct sockaddr_in *)&server->dstaddr;
1352
-
1353
-
if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
1354
-
return false;
1355
-
break;
1356
-
}
1357
-
case AF_INET6: {
1358
-
struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1359
-
struct sockaddr_in6 *srv_addr6 =
1360
-
(struct sockaddr_in6 *)&server->dstaddr;
1361
-
1362
-
if (!ipv6_addr_equal(&addr6->sin6_addr,
1363
-
&srv_addr6->sin6_addr))
1364
-
return false;
1365
-
if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
1366
-
return false;
1367
-
break;
1368
-
}
1369
-
default:
1370
-
WARN_ON(1);
1371
-
return false; /* don't expect to be here */
1372
-
}
1346
+
if (!cifs_match_ipaddr(addr, (struct sockaddr *)&server->dstaddr))
1347
+
return false;
1373
1348
1374
1349
return true;
1375
1350
}
+9
-2
fs/cifs/file.c
+9
-2
fs/cifs/file.c
···
52
52
53
53
end = (start + len - 1) / PAGE_SIZE;
54
54
xas_for_each_marked(&xas, folio, end, PAGECACHE_TAG_DIRTY) {
55
+
if (xas_retry(&xas, folio))
56
+
continue;
55
57
xas_pause(&xas);
56
58
rcu_read_unlock();
57
59
folio_lock(folio);
···
83
81
84
82
end = (start + len - 1) / PAGE_SIZE;
85
83
xas_for_each(&xas, folio, end) {
84
+
if (xas_retry(&xas, folio))
85
+
continue;
86
86
if (!folio_test_writeback(folio)) {
87
87
WARN_ONCE(1, "bad %x @%llx page %lx %lx\n",
88
88
len, start, folio_index(folio), end);
···
116
112
117
113
end = (start + len - 1) / PAGE_SIZE;
118
114
xas_for_each(&xas, folio, end) {
115
+
if (xas_retry(&xas, folio))
116
+
continue;
119
117
if (!folio_test_writeback(folio)) {
120
118
WARN_ONCE(1, "bad %x @%llx page %lx %lx\n",
121
119
len, start, folio_index(folio), end);
···
2845
2839
free_xid(xid);
2846
2840
if (rc == 0) {
2847
2841
wbc->nr_to_write = count;
2842
+
rc = len;
2848
2843
} else if (is_retryable_error(rc)) {
2849
2844
cifs_pages_write_redirty(inode, start, len);
2850
2845
} else {
···
3612
3605
3613
3606
ctx->nr_pinned_pages = rc;
3614
3607
ctx->bv = (void *)ctx->iter.bvec;
3615
-
ctx->bv_need_unpin = iov_iter_extract_will_pin(&ctx->iter);
3608
+
ctx->bv_need_unpin = iov_iter_extract_will_pin(from);
3616
3609
} else if ((iov_iter_is_bvec(from) || iov_iter_is_kvec(from)) &&
3617
3610
!is_sync_kiocb(iocb)) {
3618
3611
/*
···
4148
4141
4149
4142
ctx->nr_pinned_pages = rc;
4150
4143
ctx->bv = (void *)ctx->iter.bvec;
4151
-
ctx->bv_need_unpin = iov_iter_extract_will_pin(&ctx->iter);
4144
+
ctx->bv_need_unpin = iov_iter_extract_will_pin(to);
4152
4145
ctx->should_dirty = true;
4153
4146
} else if ((iov_iter_is_bvec(to) || iov_iter_is_kvec(to)) &&
4154
4147
!is_sync_kiocb(iocb)) {
+111
fs/cifs/misc.c
+111
fs/cifs/misc.c
···
21
21
#include "cifsfs.h"
22
22
#ifdef CONFIG_CIFS_DFS_UPCALL
23
23
#include "dns_resolve.h"
24
+
#include "dfs_cache.h"
24
25
#endif
25
26
#include "fs_context.h"
26
27
#include "cached_dir.h"
···
1199
1198
cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
1200
1199
return 0;
1201
1200
}
1201
+
1202
+
/*
1203
+
* Handle weird Windows SMB server behaviour. It responds with
1204
+
* STATUS_OBJECT_NAME_INVALID code to SMB2 QUERY_INFO request for
1205
+
* "\<server>\<dfsname>\<linkpath>" DFS reference, where <dfsname> contains
1206
+
* non-ASCII unicode symbols.
1207
+
*/
1208
+
int cifs_inval_name_dfs_link_error(const unsigned int xid,
1209
+
struct cifs_tcon *tcon,
1210
+
struct cifs_sb_info *cifs_sb,
1211
+
const char *full_path,
1212
+
bool *islink)
1213
+
{
1214
+
struct cifs_ses *ses = tcon->ses;
1215
+
size_t len;
1216
+
char *path;
1217
+
char *ref_path;
1218
+
1219
+
*islink = false;
1220
+
1221
+
/*
1222
+
* Fast path - skip check when @full_path doesn't have a prefix path to
1223
+
* look up or tcon is not DFS.
1224
+
*/
1225
+
if (strlen(full_path) < 2 || !cifs_sb ||
1226
+
(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS) ||
1227
+
!is_tcon_dfs(tcon) || !ses->server->origin_fullpath)
1228
+
return 0;
1229
+
1230
+
/*
1231
+
* Slow path - tcon is DFS and @full_path has prefix path, so attempt
1232
+
* to get a referral to figure out whether it is an DFS link.
1233
+
*/
1234
+
len = strnlen(tcon->tree_name, MAX_TREE_SIZE + 1) + strlen(full_path) + 1;
1235
+
path = kmalloc(len, GFP_KERNEL);
1236
+
if (!path)
1237
+
return -ENOMEM;
1238
+
1239
+
scnprintf(path, len, "%s%s", tcon->tree_name, full_path);
1240
+
ref_path = dfs_cache_canonical_path(path + 1, cifs_sb->local_nls,
1241
+
cifs_remap(cifs_sb));
1242
+
kfree(path);
1243
+
1244
+
if (IS_ERR(ref_path)) {
1245
+
if (PTR_ERR(ref_path) != -EINVAL)
1246
+
return PTR_ERR(ref_path);
1247
+
} else {
1248
+
struct dfs_info3_param *refs = NULL;
1249
+
int num_refs = 0;
1250
+
1251
+
/*
1252
+
* XXX: we are not using dfs_cache_find() here because we might
1253
+
* end filling all the DFS cache and thus potentially
1254
+
* removing cached DFS targets that the client would eventually
1255
+
* need during failover.
1256
+
*/
1257
+
if (ses->server->ops->get_dfs_refer &&
1258
+
!ses->server->ops->get_dfs_refer(xid, ses, ref_path, &refs,
1259
+
&num_refs, cifs_sb->local_nls,
1260
+
cifs_remap(cifs_sb)))
1261
+
*islink = refs[0].server_type == DFS_TYPE_LINK;
1262
+
free_dfs_info_array(refs, num_refs);
1263
+
kfree(ref_path);
1264
+
}
1265
+
return 0;
1266
+
}
1202
1267
#endif
1268
+
1269
+
int cifs_wait_for_server_reconnect(struct TCP_Server_Info *server, bool retry)
1270
+
{
1271
+
int timeout = 10;
1272
+
int rc;
1273
+
1274
+
spin_lock(&server->srv_lock);
1275
+
if (server->tcpStatus != CifsNeedReconnect) {
1276
+
spin_unlock(&server->srv_lock);
1277
+
return 0;
1278
+
}
1279
+
timeout *= server->nr_targets;
1280
+
spin_unlock(&server->srv_lock);
1281
+
1282
+
/*
1283
+
* Give demultiplex thread up to 10 seconds to each target available for
1284
+
* reconnect -- should be greater than cifs socket timeout which is 7
1285
+
* seconds.
1286
+
*
1287
+
* On "soft" mounts we wait once. Hard mounts keep retrying until
1288
+
* process is killed or server comes back on-line.
1289
+
*/
1290
+
do {
1291
+
rc = wait_event_interruptible_timeout(server->response_q,
1292
+
(server->tcpStatus != CifsNeedReconnect),
1293
+
timeout * HZ);
1294
+
if (rc < 0) {
1295
+
cifs_dbg(FYI, "%s: aborting reconnect due to received signal\n",
1296
+
__func__);
1297
+
return -ERESTARTSYS;
1298
+
}
1299
+
1300
+
/* are we still trying to reconnect? */
1301
+
spin_lock(&server->srv_lock);
1302
+
if (server->tcpStatus != CifsNeedReconnect) {
1303
+
spin_unlock(&server->srv_lock);
1304
+
return 0;
1305
+
}
1306
+
spin_unlock(&server->srv_lock);
1307
+
} while (retry);
1308
+
1309
+
cifs_dbg(FYI, "%s: gave up waiting on reconnect\n", __func__);
1310
+
return -EHOSTDOWN;
1311
+
}
+11
-10
fs/cifs/smb2inode.c
+11
-10
fs/cifs/smb2inode.c
···
527
527
struct cifs_sb_info *cifs_sb, const char *full_path,
528
528
struct cifs_open_info_data *data, bool *adjust_tz, bool *reparse)
529
529
{
530
-
int rc;
531
530
__u32 create_options = 0;
532
531
struct cifsFileInfo *cfile;
533
532
struct cached_fid *cfid = NULL;
534
533
struct kvec err_iov[3] = {};
535
534
int err_buftype[3] = {};
535
+
bool islink;
536
+
int rc, rc2;
536
537
537
538
*adjust_tz = false;
538
539
*reparse = false;
···
581
580
SMB2_OP_QUERY_INFO, cfile, NULL, NULL,
582
581
NULL, NULL);
583
582
goto out;
584
-
} else if (rc != -EREMOTE && IS_ENABLED(CONFIG_CIFS_DFS_UPCALL) &&
585
-
hdr->Status == STATUS_OBJECT_NAME_INVALID) {
586
-
/*
587
-
* Handle weird Windows SMB server behaviour. It responds with
588
-
* STATUS_OBJECT_NAME_INVALID code to SMB2 QUERY_INFO request
589
-
* for "\<server>\<dfsname>\<linkpath>" DFS reference,
590
-
* where <dfsname> contains non-ASCII unicode symbols.
591
-
*/
592
-
rc = -EREMOTE;
583
+
} else if (rc != -EREMOTE && hdr->Status == STATUS_OBJECT_NAME_INVALID) {
584
+
rc2 = cifs_inval_name_dfs_link_error(xid, tcon, cifs_sb,
585
+
full_path, &islink);
586
+
if (rc2) {
587
+
rc = rc2;
588
+
goto out;
589
+
}
590
+
if (islink)
591
+
rc = -EREMOTE;
593
592
}
594
593
if (rc == -EREMOTE && IS_ENABLED(CONFIG_CIFS_DFS_UPCALL) && cifs_sb &&
595
594
(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS))
+13
-10
fs/cifs/smb2ops.c
+13
-10
fs/cifs/smb2ops.c
···
796
796
smb2_is_path_accessible(const unsigned int xid, struct cifs_tcon *tcon,
797
797
struct cifs_sb_info *cifs_sb, const char *full_path)
798
798
{
799
-
int rc;
800
799
__le16 *utf16_path;
801
800
__u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
802
801
int err_buftype = CIFS_NO_BUFFER;
···
803
804
struct kvec err_iov = {};
804
805
struct cifs_fid fid;
805
806
struct cached_fid *cfid;
807
+
bool islink;
808
+
int rc, rc2;
806
809
807
810
rc = open_cached_dir(xid, tcon, full_path, cifs_sb, true, &cfid);
808
811
if (!rc) {
···
834
833
835
834
if (unlikely(!hdr || err_buftype == CIFS_NO_BUFFER))
836
835
goto out;
837
-
/*
838
-
* Handle weird Windows SMB server behaviour. It responds with
839
-
* STATUS_OBJECT_NAME_INVALID code to SMB2 QUERY_INFO request
840
-
* for "\<server>\<dfsname>\<linkpath>" DFS reference,
841
-
* where <dfsname> contains non-ASCII unicode symbols.
842
-
*/
843
-
if (rc != -EREMOTE && IS_ENABLED(CONFIG_CIFS_DFS_UPCALL) &&
844
-
hdr->Status == STATUS_OBJECT_NAME_INVALID)
845
-
rc = -EREMOTE;
836
+
837
+
if (rc != -EREMOTE && hdr->Status == STATUS_OBJECT_NAME_INVALID) {
838
+
rc2 = cifs_inval_name_dfs_link_error(xid, tcon, cifs_sb,
839
+
full_path, &islink);
840
+
if (rc2) {
841
+
rc = rc2;
842
+
goto out;
843
+
}
844
+
if (islink)
845
+
rc = -EREMOTE;
846
+
}
846
847
if (rc == -EREMOTE && IS_ENABLED(CONFIG_CIFS_DFS_UPCALL) && cifs_sb &&
847
848
(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS))
848
849
rc = -EOPNOTSUPP;
+21
-61
fs/cifs/smb2pdu.c
+21
-61
fs/cifs/smb2pdu.c
···
139
139
return;
140
140
}
141
141
142
-
static int wait_for_server_reconnect(struct TCP_Server_Info *server,
143
-
__le16 smb2_command, bool retry)
144
-
{
145
-
int timeout = 10;
146
-
int rc;
147
-
148
-
spin_lock(&server->srv_lock);
149
-
if (server->tcpStatus != CifsNeedReconnect) {
150
-
spin_unlock(&server->srv_lock);
151
-
return 0;
152
-
}
153
-
timeout *= server->nr_targets;
154
-
spin_unlock(&server->srv_lock);
155
-
156
-
/*
157
-
* Return to caller for TREE_DISCONNECT and LOGOFF and CLOSE
158
-
* here since they are implicitly done when session drops.
159
-
*/
160
-
switch (smb2_command) {
161
-
/*
162
-
* BB Should we keep oplock break and add flush to exceptions?
163
-
*/
164
-
case SMB2_TREE_DISCONNECT:
165
-
case SMB2_CANCEL:
166
-
case SMB2_CLOSE:
167
-
case SMB2_OPLOCK_BREAK:
168
-
return -EAGAIN;
169
-
}
170
-
171
-
/*
172
-
* Give demultiplex thread up to 10 seconds to each target available for
173
-
* reconnect -- should be greater than cifs socket timeout which is 7
174
-
* seconds.
175
-
*
176
-
* On "soft" mounts we wait once. Hard mounts keep retrying until
177
-
* process is killed or server comes back on-line.
178
-
*/
179
-
do {
180
-
rc = wait_event_interruptible_timeout(server->response_q,
181
-
(server->tcpStatus != CifsNeedReconnect),
182
-
timeout * HZ);
183
-
if (rc < 0) {
184
-
cifs_dbg(FYI, "%s: aborting reconnect due to received signal\n",
185
-
__func__);
186
-
return -ERESTARTSYS;
187
-
}
188
-
189
-
/* are we still trying to reconnect? */
190
-
spin_lock(&server->srv_lock);
191
-
if (server->tcpStatus != CifsNeedReconnect) {
192
-
spin_unlock(&server->srv_lock);
193
-
return 0;
194
-
}
195
-
spin_unlock(&server->srv_lock);
196
-
} while (retry);
197
-
198
-
cifs_dbg(FYI, "%s: gave up waiting on reconnect\n", __func__);
199
-
return -EHOSTDOWN;
200
-
}
201
-
202
142
static int
203
143
smb2_reconnect(__le16 smb2_command, struct cifs_tcon *tcon,
204
144
struct TCP_Server_Info *server)
···
183
243
(!tcon->ses->server) || !server)
184
244
return -EIO;
185
245
186
-
rc = wait_for_server_reconnect(server, smb2_command, tcon->retry);
246
+
spin_lock(&server->srv_lock);
247
+
if (server->tcpStatus == CifsNeedReconnect) {
248
+
/*
249
+
* Return to caller for TREE_DISCONNECT and LOGOFF and CLOSE
250
+
* here since they are implicitly done when session drops.
251
+
*/
252
+
switch (smb2_command) {
253
+
/*
254
+
* BB Should we keep oplock break and add flush to exceptions?
255
+
*/
256
+
case SMB2_TREE_DISCONNECT:
257
+
case SMB2_CANCEL:
258
+
case SMB2_CLOSE:
259
+
case SMB2_OPLOCK_BREAK:
260
+
spin_unlock(&server->srv_lock);
261
+
return -EAGAIN;
262
+
}
263
+
}
264
+
spin_unlock(&server->srv_lock);
265
+
266
+
rc = cifs_wait_for_server_reconnect(server, tcon->retry);
187
267
if (rc)
188
268
return rc;
189
269
+1
-1
fs/cifs/smbdirect.c
+1
-1
fs/cifs/smbdirect.c