Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'v6.16-rc-part1-smb-client-fixes' of git://git.samba.org/sfrench/cifs-2.6
Pull smb client updates from Steve French:
- multichannel fixes (mostly reconnect related), and clarification of
locking documentation
- automount null pointer check fix
- fixes to add support for ParentLeaseKey
- minor cleanup
- smb1/cifs fixes
* tag 'v6.16-rc-part1-smb-client-fixes' of git://git.samba.org/sfrench/cifs-2.6:
cifs: update the lock ordering comments with new mutex
cifs: dns resolution is needed only for primary channel
cifs: update dstaddr whenever channel iface is updated
cifs: reset connections for all channels when reconnect requested
smb: client: use ParentLeaseKey in cifs_do_create
smb: client: use ParentLeaseKey in open_cached_dir
smb: client: add ParentLeaseKey support
cifs: Fix cifs_query_path_info() for Windows NT servers
cifs: Fix validation of SMB1 query reparse point response
cifs: Correctly set SMB1 SessionKey field in Session Setup Request
cifs: Fix encoding of SMB1 Session Setup NTLMSSP Request in non-UNICODE mode
smb: client: add NULL check in automount_fullpath
smb: client: Remove an unused function and variable
+130
-97
+23
-1
fs/smb/client/cached_dir.c
+23
-1
fs/smb/client/cached_dir.c
···
155
155
struct cached_fids *cfids;
156
156
const char *npath;
157
157
int retries = 0, cur_sleep = 1;
158
+
__le32 lease_flags = 0;
158
159
159
160
if (cifs_sb->root == NULL)
160
161
return -ENOENT;
···
202
201
}
203
202
spin_unlock(&cfids->cfid_list_lock);
204
203
204
+
pfid = &cfid->fid;
205
+
205
206
/*
206
207
* Skip any prefix paths in @path as lookup_noperm_positive_unlocked() ends up
207
208
* calling ->lookup() which already adds those through
···
225
222
rc = -ENOENT;
226
223
goto out;
227
224
}
225
+
if (dentry->d_parent && server->dialect >= SMB30_PROT_ID) {
226
+
struct cached_fid *parent_cfid;
227
+
228
+
spin_lock(&cfids->cfid_list_lock);
229
+
list_for_each_entry(parent_cfid, &cfids->entries, entry) {
230
+
if (parent_cfid->dentry == dentry->d_parent) {
231
+
cifs_dbg(FYI, "found a parent cached file handle\n");
232
+
if (parent_cfid->has_lease && parent_cfid->time) {
233
+
lease_flags
234
+
|= SMB2_LEASE_FLAG_PARENT_LEASE_KEY_SET_LE;
235
+
memcpy(pfid->parent_lease_key,
236
+
parent_cfid->fid.lease_key,
237
+
SMB2_LEASE_KEY_SIZE);
238
+
}
239
+
break;
240
+
}
241
+
}
242
+
spin_unlock(&cfids->cfid_list_lock);
243
+
}
228
244
}
229
245
cfid->dentry = dentry;
230
246
cfid->tcon = tcon;
···
258
236
if (smb3_encryption_required(tcon))
259
237
flags |= CIFS_TRANSFORM_REQ;
260
238
261
-
pfid = &cfid->fid;
262
239
server->ops->new_lease_key(pfid);
263
240
264
241
memset(rqst, 0, sizeof(rqst));
···
277
256
FILE_READ_EA,
278
257
.disposition = FILE_OPEN,
279
258
.fid = pfid,
259
+
.lease_flags = lease_flags,
280
260
.replay = !!(retries),
281
261
};
282
262
-1
fs/smb/client/cifsfs.c
-1
fs/smb/client/cifsfs.c
+12
-6
fs/smb/client/cifsglob.h
+12
-6
fs/smb/client/cifsglob.h
···
556
556
void (*set_oplock_level)(struct cifsInodeInfo *cinode, __u32 oplock, __u16 epoch,
557
557
bool *purge_cache);
558
558
/* create lease context buffer for CREATE request */
559
-
char * (*create_lease_buf)(u8 *lease_key, u8 oplock);
559
+
char * (*create_lease_buf)(u8 *lease_key, u8 oplock, u8 *parent_lease_key, __le32 le_flags);
560
560
/* parse lease context buffer and return oplock/epoch info */
561
561
__u8 (*parse_lease_buf)(void *buf, __u16 *epoch, char *lkey);
562
562
ssize_t (*copychunk_range)(const unsigned int,
···
773
773
char workstation_RFC1001_name[RFC1001_NAME_LEN_WITH_NULL];
774
774
__u32 sequence_number; /* for signing, protected by srv_mutex */
775
775
__u32 reconnect_instance; /* incremented on each reconnect */
776
+
__le32 session_key_id; /* retrieved from negotiate response and send in session setup request */
776
777
struct session_key session_key;
777
778
unsigned long lstrp; /* when we got last response from this server */
778
779
struct cifs_secmech secmech; /* crypto sec mech functs, descriptors */
···
1442
1441
bool reconnect:1;
1443
1442
bool replay:1; /* indicates that this open is for a replay */
1444
1443
struct kvec *ea_cctx;
1444
+
__le32 lease_flags;
1445
1445
};
1446
1446
1447
1447
struct cifs_fid {
···
1450
1448
__u64 persistent_fid; /* persist file id for smb2 */
1451
1449
__u64 volatile_fid; /* volatile file id for smb2 */
1452
1450
__u8 lease_key[SMB2_LEASE_KEY_SIZE]; /* lease key for smb2 */
1451
+
__u8 parent_lease_key[SMB2_LEASE_KEY_SIZE];
1453
1452
__u8 create_guid[16];
1454
1453
__u32 access;
1455
1454
struct cifs_pending_open *pending_open;
···
1991
1988
* TCP_Server_Info-> TCP_Server_Info cifs_get_tcp_session
1992
1989
* reconnect_mutex
1993
1990
* TCP_Server_Info->srv_mutex TCP_Server_Info cifs_get_tcp_session
1994
-
* cifs_ses->session_mutex cifs_ses sesInfoAlloc
1995
-
* cifs_tcon
1991
+
* cifs_ses->session_mutex cifs_ses sesInfoAlloc
1996
1992
* cifs_tcon->open_file_lock cifs_tcon->openFileList tconInfoAlloc
1997
1993
* cifs_tcon->pending_opens
1998
1994
* cifs_tcon->stat_lock cifs_tcon->bytes_read tconInfoAlloc
···
2010
2008
* ->oplock_credits
2011
2009
* ->reconnect_instance
2012
2010
* cifs_ses->ses_lock (anything that is not protected by another lock and can change)
2011
+
* sesInfoAlloc
2013
2012
* cifs_ses->iface_lock cifs_ses->iface_list sesInfoAlloc
2014
2013
* ->iface_count
2015
2014
* ->iface_last_update
2016
-
* cifs_ses->chan_lock cifs_ses->chans
2015
+
* cifs_ses->chan_lock cifs_ses->chans sesInfoAlloc
2017
2016
* ->chans_need_reconnect
2018
2017
* ->chans_in_reconnect
2019
2018
* cifs_tcon->tc_lock (anything that is not protected by another lock and can change)
2019
+
* tcon_info_alloc
2020
2020
* inode->i_rwsem, taken by fs/netfs/locking.c e.g. should be taken before cifsInodeInfo locks
2021
2021
* cifsInodeInfo->open_file_lock cifsInodeInfo->openFileList cifs_alloc_inode
2022
2022
* cifsInodeInfo->writers_lock cifsInodeInfo->writers cifsInodeInfo_alloc
2023
2023
* cifsInodeInfo->lock_sem cifsInodeInfo->llist cifs_init_once
2024
2024
* ->can_cache_brlcks
2025
2025
* cifsInodeInfo->deferred_lock cifsInodeInfo->deferred_closes cifsInodeInfo_alloc
2026
-
* cached_fids->cfid_list_lock cifs_tcon->cfids->entries init_cached_dirs
2027
-
* cifsFileInfo->fh_mutex cifsFileInfo cifs_new_fileinfo
2026
+
* cached_fids->cfid_list_lock cifs_tcon->cfids->entries init_cached_dirs
2027
+
* cached_fid->fid_lock (anything that is not protected by another lock and can change)
2028
+
* init_cached_dir
2029
+
* cifsFileInfo->fh_mutex cifsFileInfo cifs_new_fileinfo
2028
2030
* cifsFileInfo->file_info_lock cifsFileInfo->count cifs_new_fileinfo
2029
2031
* ->invalidHandle initiate_cifs_search
2030
2032
* ->oplock_break_cancelled
+3
-3
fs/smb/client/cifspdu.h
+3
-3
fs/smb/client/cifspdu.h
···
597
597
__le16 MaxBufferSize;
598
598
__le16 MaxMpxCount;
599
599
__le16 VcNumber;
600
-
__u32 SessionKey;
600
+
__le32 SessionKey;
601
601
__le16 SecurityBlobLength;
602
602
__u32 Reserved;
603
603
__le32 Capabilities; /* see below */
···
616
616
__le16 MaxBufferSize;
617
617
__le16 MaxMpxCount;
618
618
__le16 VcNumber;
619
-
__u32 SessionKey;
619
+
__le32 SessionKey;
620
620
__le16 CaseInsensitivePasswordLength; /* ASCII password len */
621
621
__le16 CaseSensitivePasswordLength; /* Unicode password length*/
622
622
__u32 Reserved; /* see below */
···
654
654
__le16 MaxBufferSize;
655
655
__le16 MaxMpxCount;
656
656
__le16 VcNumber;
657
-
__u32 SessionKey;
657
+
__le32 SessionKey;
658
658
__le16 PasswordLength;
659
659
__u32 Reserved; /* encrypt key len and offset */
660
660
__le16 ByteCount;
+19
-2
fs/smb/client/cifssmb.c
+19
-2
fs/smb/client/cifssmb.c
···
498
498
server->max_rw = le32_to_cpu(pSMBr->MaxRawSize);
499
499
cifs_dbg(NOISY, "Max buf = %d\n", ses->server->maxBuf);
500
500
server->capabilities = le32_to_cpu(pSMBr->Capabilities);
501
+
server->session_key_id = pSMBr->SessionKey;
501
502
server->timeAdj = (int)(__s16)le16_to_cpu(pSMBr->ServerTimeZone);
502
503
server->timeAdj *= 60;
503
504
···
2754
2753
2755
2754
io_req->TotalParameterCount = 0;
2756
2755
io_req->TotalDataCount = 0;
2757
-
io_req->MaxParameterCount = cpu_to_le32(2);
2756
+
io_req->MaxParameterCount = cpu_to_le32(0);
2758
2757
/* BB find exact data count max from sess structure BB */
2759
2758
io_req->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
2760
-
io_req->MaxSetupCount = 4;
2759
+
io_req->MaxSetupCount = 1;
2761
2760
io_req->Reserved = 0;
2762
2761
io_req->ParameterOffset = 0;
2763
2762
io_req->DataCount = 0;
···
2780
2779
data_count = le32_to_cpu(io_rsp->DataCount);
2781
2780
if (get_bcc(&io_rsp->hdr) < 2 || data_offset > 512 ||
2782
2781
!data_count || data_count > 2048) {
2782
+
rc = -EIO;
2783
+
goto error;
2784
+
}
2785
+
2786
+
/* SetupCount must be 1, otherwise offset to ByteCount is incorrect. */
2787
+
if (io_rsp->SetupCount != 1) {
2788
+
rc = -EIO;
2789
+
goto error;
2790
+
}
2791
+
2792
+
/*
2793
+
* ReturnedDataLen is output length of executed IOCTL.
2794
+
* DataCount is output length transferred over network.
2795
+
* Check that we have full FSCTL_GET_REPARSE_POINT buffer.
2796
+
*/
2797
+
if (data_count != le16_to_cpu(io_rsp->ReturnedDataLen)) {
2783
2798
rc = -EIO;
2784
2799
goto error;
2785
2800
}
+9
-1
fs/smb/client/connect.c
+9
-1
fs/smb/client/connect.c
···
377
377
if (!cifs_tcp_ses_needs_reconnect(server, 1))
378
378
return 0;
379
379
380
+
/*
381
+
* if smb session has been marked for reconnect, also reconnect all
382
+
* connections. This way, the other connections do not end up bad.
383
+
*/
384
+
if (mark_smb_session)
385
+
cifs_signal_cifsd_for_reconnect(server, mark_smb_session);
386
+
380
387
cifs_mark_tcp_ses_conns_for_reconnect(server, mark_smb_session);
381
388
382
389
cifs_abort_connection(server);
···
392
385
try_to_freeze();
393
386
cifs_server_lock(server);
394
387
395
-
if (!cifs_swn_set_server_dstaddr(server)) {
388
+
if (!cifs_swn_set_server_dstaddr(server) &&
389
+
!SERVER_IS_CHAN(server)) {
396
390
/* resolve the hostname again to make sure that IP address is up-to-date */
397
391
rc = reconn_set_ipaddr_from_hostname(server);
398
392
cifs_dbg(FYI, "%s: reconn_set_ipaddr_from_hostname: rc=%d\n", __func__, rc);
+23
fs/smb/client/dir.c
+23
fs/smb/client/dir.c
···
23
23
#include "fs_context.h"
24
24
#include "cifs_ioctl.h"
25
25
#include "fscache.h"
26
+
#include "cached_dir.h"
26
27
27
28
static void
28
29
renew_parental_timestamps(struct dentry *direntry)
···
191
190
struct TCP_Server_Info *server = tcon->ses->server;
192
191
struct cifs_open_parms oparms;
193
192
int rdwr_for_fscache = 0;
193
+
__le32 lease_flags = 0;
194
194
195
195
*oplock = 0;
196
196
if (tcon->ses->server->oplocks)
···
314
312
create_options |= CREATE_OPTION_READONLY;
315
313
316
314
retry_open:
315
+
if (tcon->cfids && direntry->d_parent && server->dialect >= SMB30_PROT_ID) {
316
+
struct cached_fid *parent_cfid;
317
+
318
+
spin_lock(&tcon->cfids->cfid_list_lock);
319
+
list_for_each_entry(parent_cfid, &tcon->cfids->entries, entry) {
320
+
if (parent_cfid->dentry == direntry->d_parent) {
321
+
cifs_dbg(FYI, "found a parent cached file handle\n");
322
+
if (parent_cfid->has_lease && parent_cfid->time) {
323
+
lease_flags
324
+
|= SMB2_LEASE_FLAG_PARENT_LEASE_KEY_SET_LE;
325
+
memcpy(fid->parent_lease_key,
326
+
parent_cfid->fid.lease_key,
327
+
SMB2_LEASE_KEY_SIZE);
328
+
}
329
+
break;
330
+
}
331
+
}
332
+
spin_unlock(&tcon->cfids->cfid_list_lock);
333
+
}
334
+
317
335
oparms = (struct cifs_open_parms) {
318
336
.tcon = tcon,
319
337
.cifs_sb = cifs_sb,
···
342
320
.disposition = disposition,
343
321
.path = full_path,
344
322
.fid = fid,
323
+
.lease_flags = lease_flags,
345
324
.mode = mode,
346
325
};
347
326
rc = server->ops->open(xid, &oparms, oplock, buf);
+8
fs/smb/client/misc.c
+8
fs/smb/client/misc.c
···
326
326
if (smb->Command == SMB_COM_LOCKING_ANDX)
327
327
return 0;
328
328
329
+
/*
330
+
* Windows NT server returns error resposne (e.g. STATUS_DELETE_PENDING
331
+
* or STATUS_OBJECT_NAME_NOT_FOUND or ERRDOS/ERRbadfile or any other)
332
+
* for some TRANS2 requests without the RESPONSE flag set in header.
333
+
*/
334
+
if (smb->Command == SMB_COM_TRANSACTION2 && smb->Status.CifsError != 0)
335
+
return 0;
336
+
329
337
cifs_dbg(VFS, "Server sent request, not response. mid=%u\n",
330
338
get_mid(smb));
331
339
return 1;
+3
fs/smb/client/namespace.c
+3
fs/smb/client/namespace.c
+15
-10
fs/smb/client/sess.c
+15
-10
fs/smb/client/sess.c
···
445
445
446
446
ses->chans[chan_index].iface = iface;
447
447
spin_unlock(&ses->chan_lock);
448
+
449
+
spin_lock(&server->srv_lock);
450
+
memcpy(&server->dstaddr, &iface->sockaddr, sizeof(server->dstaddr));
451
+
spin_unlock(&server->srv_lock);
448
452
}
449
453
450
454
static int
···
632
628
USHRT_MAX));
633
629
pSMB->req.MaxMpxCount = cpu_to_le16(server->maxReq);
634
630
pSMB->req.VcNumber = cpu_to_le16(1);
631
+
pSMB->req.SessionKey = server->session_key_id;
635
632
636
633
/* Now no need to set SMBFLG_CASELESS or obsolete CANONICAL PATH */
637
634
···
1689
1684
pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
1690
1685
1691
1686
capabilities = cifs_ssetup_hdr(ses, server, pSMB);
1692
-
if ((pSMB->req.hdr.Flags2 & SMBFLG2_UNICODE) == 0) {
1693
-
cifs_dbg(VFS, "NTLMSSP requires Unicode support\n");
1694
-
return -ENOSYS;
1695
-
}
1696
-
1697
1687
pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
1698
1688
capabilities |= CAP_EXTENDED_SECURITY;
1699
1689
pSMB->req.Capabilities |= cpu_to_le32(capabilities);
1700
1690
1701
1691
bcc_ptr = sess_data->iov[2].iov_base;
1702
-
/* unicode strings must be word aligned */
1703
-
if (!IS_ALIGNED(sess_data->iov[0].iov_len + sess_data->iov[1].iov_len, 2)) {
1704
-
*bcc_ptr = 0;
1705
-
bcc_ptr++;
1692
+
1693
+
if (pSMB->req.hdr.Flags2 & SMBFLG2_UNICODE) {
1694
+
/* unicode strings must be word aligned */
1695
+
if (!IS_ALIGNED(sess_data->iov[0].iov_len + sess_data->iov[1].iov_len, 2)) {
1696
+
*bcc_ptr = 0;
1697
+
bcc_ptr++;
1698
+
}
1699
+
unicode_oslm_strings(&bcc_ptr, sess_data->nls_cp);
1700
+
} else {
1701
+
ascii_oslm_strings(&bcc_ptr, sess_data->nls_cp);
1706
1702
}
1707
-
unicode_oslm_strings(&bcc_ptr, sess_data->nls_cp);
1708
1703
1709
1704
sess_data->iov[2].iov_len = (long) bcc_ptr -
1710
1705
(long) sess_data->iov[2].iov_base;
+5
-2
fs/smb/client/smb2ops.c
+5
-2
fs/smb/client/smb2ops.c
···
4069
4069
}
4070
4070
4071
4071
static char *
4072
-
smb2_create_lease_buf(u8 *lease_key, u8 oplock)
4072
+
smb2_create_lease_buf(u8 *lease_key, u8 oplock, u8 *parent_lease_key, __le32 flags)
4073
4073
{
4074
4074
struct create_lease *buf;
4075
4075
···
4095
4095
}
4096
4096
4097
4097
static char *
4098
-
smb3_create_lease_buf(u8 *lease_key, u8 oplock)
4098
+
smb3_create_lease_buf(u8 *lease_key, u8 oplock, u8 *parent_lease_key, __le32 flags)
4099
4099
{
4100
4100
struct create_lease_v2 *buf;
4101
4101
···
4105
4105
4106
4106
memcpy(&buf->lcontext.LeaseKey, lease_key, SMB2_LEASE_KEY_SIZE);
4107
4107
buf->lcontext.LeaseState = map_oplock_to_lease(oplock);
4108
+
buf->lcontext.LeaseFlags = flags;
4109
+
if (flags & SMB2_LEASE_FLAG_PARENT_LEASE_KEY_SET_LE)
4110
+
memcpy(&buf->lcontext.ParentLeaseKey, parent_lease_key, SMB2_LEASE_KEY_SIZE);
4108
4111
4109
4112
buf->ccontext.DataOffset = cpu_to_le16(offsetof
4110
4113
(struct create_lease_v2, lcontext));
+10
-68
fs/smb/client/smb2pdu.c
+10
-68
fs/smb/client/smb2pdu.c
···
2392
2392
add_lease_context(struct TCP_Server_Info *server,
2393
2393
struct smb2_create_req *req,
2394
2394
struct kvec *iov,
2395
-
unsigned int *num_iovec, u8 *lease_key, __u8 *oplock)
2395
+
unsigned int *num_iovec,
2396
+
u8 *lease_key,
2397
+
__u8 *oplock,
2398
+
u8 *parent_lease_key,
2399
+
__le32 flags)
2396
2400
{
2397
2401
unsigned int num = *num_iovec;
2398
2402
2399
-
iov[num].iov_base = server->ops->create_lease_buf(lease_key, *oplock);
2403
+
iov[num].iov_base = server->ops->create_lease_buf(lease_key, *oplock,
2404
+
parent_lease_key, flags);
2400
2405
if (iov[num].iov_base == NULL)
2401
2406
return -ENOMEM;
2402
2407
iov[num].iov_len = server->vals->create_lease_size;
···
3074
3069
req->RequestedOplockLevel = *oplock; /* no srv lease support */
3075
3070
else {
3076
3071
rc = add_lease_context(server, req, iov, &n_iov,
3077
-
oparms->fid->lease_key, oplock);
3072
+
oparms->fid->lease_key, oplock,
3073
+
oparms->fid->parent_lease_key,
3074
+
oparms->lease_flags);
3078
3075
if (rc)
3079
3076
return rc;
3080
3077
}
···
5914
5907
copy_posix_fs_info_to_kstatfs(info, fsdata);
5915
5908
5916
5909
posix_qfsinf_exit:
5917
-
free_rsp_buf(resp_buftype, rsp_iov.iov_base);
5918
-
5919
-
if (is_replayable_error(rc) &&
5920
-
smb2_should_replay(tcon, &retries, &cur_sleep))
5921
-
goto replay_again;
5922
-
5923
-
return rc;
5924
-
}
5925
-
5926
-
int
5927
-
SMB2_QFS_info(const unsigned int xid, struct cifs_tcon *tcon,
5928
-
u64 persistent_fid, u64 volatile_fid, struct kstatfs *fsdata)
5929
-
{
5930
-
struct smb_rqst rqst;
5931
-
struct smb2_query_info_rsp *rsp = NULL;
5932
-
struct kvec iov;
5933
-
struct kvec rsp_iov;
5934
-
int rc = 0;
5935
-
int resp_buftype;
5936
-
struct cifs_ses *ses = tcon->ses;
5937
-
struct TCP_Server_Info *server;
5938
-
struct smb2_fs_full_size_info *info = NULL;
5939
-
int flags = 0;
5940
-
int retries = 0, cur_sleep = 1;
5941
-
5942
-
replay_again:
5943
-
/* reinitialize for possible replay */
5944
-
flags = 0;
5945
-
server = cifs_pick_channel(ses);
5946
-
5947
-
rc = build_qfs_info_req(&iov, tcon, server,
5948
-
FS_FULL_SIZE_INFORMATION,
5949
-
sizeof(struct smb2_fs_full_size_info),
5950
-
persistent_fid, volatile_fid);
5951
-
if (rc)
5952
-
return rc;
5953
-
5954
-
if (smb3_encryption_required(tcon))
5955
-
flags |= CIFS_TRANSFORM_REQ;
5956
-
5957
-
memset(&rqst, 0, sizeof(struct smb_rqst));
5958
-
rqst.rq_iov = &iov;
5959
-
rqst.rq_nvec = 1;
5960
-
5961
-
if (retries)
5962
-
smb2_set_replay(server, &rqst);
5963
-
5964
-
rc = cifs_send_recv(xid, ses, server,
5965
-
&rqst, &resp_buftype, flags, &rsp_iov);
5966
-
free_qfs_info_req(&iov);
5967
-
if (rc) {
5968
-
cifs_stats_fail_inc(tcon, SMB2_QUERY_INFO_HE);
5969
-
goto qfsinf_exit;
5970
-
}
5971
-
rsp = (struct smb2_query_info_rsp *)rsp_iov.iov_base;
5972
-
5973
-
info = (struct smb2_fs_full_size_info *)(
5974
-
le16_to_cpu(rsp->OutputBufferOffset) + (char *)rsp);
5975
-
rc = smb2_validate_iov(le16_to_cpu(rsp->OutputBufferOffset),
5976
-
le32_to_cpu(rsp->OutputBufferLength), &rsp_iov,
5977
-
sizeof(struct smb2_fs_full_size_info));
5978
-
if (!rc)
5979
-
smb2_copy_fs_info_to_kstatfs(info, fsdata);
5980
-
5981
-
qfsinf_exit:
5982
5910
free_rsp_buf(resp_buftype, rsp_iov.iov_base);
5983
5911
5984
5912
if (is_replayable_error(rc) &&
-3
fs/smb/client/smb2proto.h
-3
fs/smb/client/smb2proto.h
···
259
259
__u64 volatile_fid);
260
260
extern int smb2_handle_cancelled_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server);
261
261
void smb2_cancelled_close_fid(struct work_struct *work);
262
-
extern int SMB2_QFS_info(const unsigned int xid, struct cifs_tcon *tcon,
263
-
u64 persistent_file_id, u64 volatile_file_id,
264
-
struct kstatfs *FSData);
265
262
extern int SMB311_posix_qfs_info(const unsigned int xid, struct cifs_tcon *tcon,
266
263
u64 persistent_file_id, u64 volatile_file_id,
267
264
struct kstatfs *FSData);