2 * SMB2 version specific operations
4 * Copyright (c) 2012, Jeff Layton <jlayton@redhat.com>
6 * This library is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License v2 as published
8 * by the Free Software Foundation.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
13 * the GNU Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public License
16 * along with this library; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 #include <linux/pagemap.h>
21 #include <linux/vfs.h>
22 #include <linux/falloc.h>
25 #include "smb2proto.h"
26 #include "cifsproto.h"
27 #include "cifs_debug.h"
28 #include "cifs_unicode.h"
29 #include "smb2status.h"
33 change_conf(struct TCP_Server_Info
*server
)
35 server
->credits
+= server
->echo_credits
+ server
->oplock_credits
;
36 server
->oplock_credits
= server
->echo_credits
= 0;
37 switch (server
->credits
) {
41 server
->echoes
= false;
42 server
->oplocks
= false;
43 cifs_dbg(VFS
, "disabling echoes and oplocks\n");
46 server
->echoes
= true;
47 server
->oplocks
= false;
48 server
->echo_credits
= 1;
49 cifs_dbg(FYI
, "disabling oplocks\n");
52 server
->echoes
= true;
53 server
->oplocks
= true;
54 server
->echo_credits
= 1;
55 server
->oplock_credits
= 1;
57 server
->credits
-= server
->echo_credits
+ server
->oplock_credits
;
62 smb2_add_credits(struct TCP_Server_Info
*server
, const unsigned int add
,
66 spin_lock(&server
->req_lock
);
67 val
= server
->ops
->get_credits_field(server
, optype
);
70 if (server
->in_flight
== 0 && (optype
& CIFS_OP_MASK
) != CIFS_NEG_OP
)
71 rc
= change_conf(server
);
73 * Sometimes server returns 0 credits on oplock break ack - we need to
74 * rebalance credits in this case.
76 else if (server
->in_flight
> 0 && server
->oplock_credits
== 0 &&
78 if (server
->credits
> 1) {
80 server
->oplock_credits
++;
83 spin_unlock(&server
->req_lock
);
84 wake_up(&server
->request_q
);
86 cifs_reconnect(server
);
90 smb2_set_credits(struct TCP_Server_Info
*server
, const int val
)
92 spin_lock(&server
->req_lock
);
93 server
->credits
= val
;
94 spin_unlock(&server
->req_lock
);
98 smb2_get_credits_field(struct TCP_Server_Info
*server
, const int optype
)
102 return &server
->echo_credits
;
104 return &server
->oplock_credits
;
106 return &server
->credits
;
111 smb2_get_credits(struct mid_q_entry
*mid
)
113 return le16_to_cpu(((struct smb2_hdr
*)mid
->resp_buf
)->CreditRequest
);
117 smb2_wait_mtu_credits(struct TCP_Server_Info
*server
, unsigned int size
,
118 unsigned int *num
, unsigned int *credits
)
121 unsigned int scredits
;
123 spin_lock(&server
->req_lock
);
125 if (server
->credits
<= 0) {
126 spin_unlock(&server
->req_lock
);
127 cifs_num_waiters_inc(server
);
128 rc
= wait_event_killable(server
->request_q
,
129 has_credits(server
, &server
->credits
));
130 cifs_num_waiters_dec(server
);
133 spin_lock(&server
->req_lock
);
135 if (server
->tcpStatus
== CifsExiting
) {
136 spin_unlock(&server
->req_lock
);
140 scredits
= server
->credits
;
141 /* can deadlock with reopen */
143 *num
= SMB2_MAX_BUFFER_SIZE
;
148 /* leave one credit for a possible reopen */
150 *num
= min_t(unsigned int, size
,
151 scredits
* SMB2_MAX_BUFFER_SIZE
);
153 *credits
= DIV_ROUND_UP(*num
, SMB2_MAX_BUFFER_SIZE
);
154 server
->credits
-= *credits
;
159 spin_unlock(&server
->req_lock
);
164 smb2_get_next_mid(struct TCP_Server_Info
*server
)
167 /* for SMB2 we need the current value */
168 spin_lock(&GlobalMid_Lock
);
169 mid
= server
->CurrentMid
++;
170 spin_unlock(&GlobalMid_Lock
);
174 static struct mid_q_entry
*
175 smb2_find_mid(struct TCP_Server_Info
*server
, char *buf
)
177 struct mid_q_entry
*mid
;
178 struct smb2_hdr
*hdr
= (struct smb2_hdr
*)buf
;
180 spin_lock(&GlobalMid_Lock
);
181 list_for_each_entry(mid
, &server
->pending_mid_q
, qhead
) {
182 if ((mid
->mid
== hdr
->MessageId
) &&
183 (mid
->mid_state
== MID_REQUEST_SUBMITTED
) &&
184 (mid
->command
== hdr
->Command
)) {
185 spin_unlock(&GlobalMid_Lock
);
189 spin_unlock(&GlobalMid_Lock
);
194 smb2_dump_detail(void *buf
)
196 #ifdef CONFIG_CIFS_DEBUG2
197 struct smb2_hdr
*smb
= (struct smb2_hdr
*)buf
;
199 cifs_dbg(VFS
, "Cmd: %d Err: 0x%x Flags: 0x%x Mid: %llu Pid: %d\n",
200 smb
->Command
, smb
->Status
, smb
->Flags
, smb
->MessageId
,
202 cifs_dbg(VFS
, "smb buf %p len %u\n", smb
, smb2_calc_size(smb
));
207 smb2_need_neg(struct TCP_Server_Info
*server
)
209 return server
->max_read
== 0;
213 smb2_negotiate(const unsigned int xid
, struct cifs_ses
*ses
)
216 ses
->server
->CurrentMid
= 0;
217 rc
= SMB2_negotiate(xid
, ses
);
218 /* BB we probably don't need to retry with modern servers */
225 smb2_negotiate_wsize(struct cifs_tcon
*tcon
, struct smb_vol
*volume_info
)
227 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
230 /* start with specified wsize, or default */
231 wsize
= volume_info
->wsize
? volume_info
->wsize
: CIFS_DEFAULT_IOSIZE
;
232 wsize
= min_t(unsigned int, wsize
, server
->max_write
);
234 if (!(server
->capabilities
& SMB2_GLOBAL_CAP_LARGE_MTU
))
235 wsize
= min_t(unsigned int, wsize
, SMB2_MAX_BUFFER_SIZE
);
241 smb2_negotiate_rsize(struct cifs_tcon
*tcon
, struct smb_vol
*volume_info
)
243 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
246 /* start with specified rsize, or default */
247 rsize
= volume_info
->rsize
? volume_info
->rsize
: CIFS_DEFAULT_IOSIZE
;
248 rsize
= min_t(unsigned int, rsize
, server
->max_read
);
250 if (!(server
->capabilities
& SMB2_GLOBAL_CAP_LARGE_MTU
))
251 rsize
= min_t(unsigned int, rsize
, SMB2_MAX_BUFFER_SIZE
);
256 #ifdef CONFIG_CIFS_STATS2
258 SMB3_request_interfaces(const unsigned int xid
, struct cifs_tcon
*tcon
)
261 unsigned int ret_data_len
= 0;
262 struct network_interface_info_ioctl_rsp
*out_buf
;
264 rc
= SMB2_ioctl(xid
, tcon
, NO_FILE_ID
, NO_FILE_ID
,
265 FSCTL_QUERY_NETWORK_INTERFACE_INFO
, true /* is_fsctl */,
266 NULL
/* no data input */, 0 /* no data input */,
267 (char **)&out_buf
, &ret_data_len
);
269 cifs_dbg(VFS
, "error %d on ioctl to get interface list\n", rc
);
270 else if (ret_data_len
< sizeof(struct network_interface_info_ioctl_rsp
)) {
271 cifs_dbg(VFS
, "server returned bad net interface info buf\n");
274 /* Dump info on first interface */
275 cifs_dbg(FYI
, "Adapter Capability 0x%x\t",
276 le32_to_cpu(out_buf
->Capability
));
277 cifs_dbg(FYI
, "Link Speed %lld\n",
278 le64_to_cpu(out_buf
->LinkSpeed
));
286 smb3_qfs_tcon(const unsigned int xid
, struct cifs_tcon
*tcon
)
289 __le16 srch_path
= 0; /* Null - open root of share */
290 u8 oplock
= SMB2_OPLOCK_LEVEL_NONE
;
291 struct cifs_open_parms oparms
;
295 oparms
.desired_access
= FILE_READ_ATTRIBUTES
;
296 oparms
.disposition
= FILE_OPEN
;
297 oparms
.create_options
= 0;
299 oparms
.reconnect
= false;
301 rc
= SMB2_open(xid
, &oparms
, &srch_path
, &oplock
, NULL
, NULL
);
305 #ifdef CONFIG_CIFS_STATS2
306 SMB3_request_interfaces(xid
, tcon
);
309 SMB2_QFS_attr(xid
, tcon
, fid
.persistent_fid
, fid
.volatile_fid
,
310 FS_ATTRIBUTE_INFORMATION
);
311 SMB2_QFS_attr(xid
, tcon
, fid
.persistent_fid
, fid
.volatile_fid
,
312 FS_DEVICE_INFORMATION
);
313 SMB2_QFS_attr(xid
, tcon
, fid
.persistent_fid
, fid
.volatile_fid
,
314 FS_SECTOR_SIZE_INFORMATION
); /* SMB3 specific */
315 SMB2_close(xid
, tcon
, fid
.persistent_fid
, fid
.volatile_fid
);
320 smb2_qfs_tcon(const unsigned int xid
, struct cifs_tcon
*tcon
)
323 __le16 srch_path
= 0; /* Null - open root of share */
324 u8 oplock
= SMB2_OPLOCK_LEVEL_NONE
;
325 struct cifs_open_parms oparms
;
329 oparms
.desired_access
= FILE_READ_ATTRIBUTES
;
330 oparms
.disposition
= FILE_OPEN
;
331 oparms
.create_options
= 0;
333 oparms
.reconnect
= false;
335 rc
= SMB2_open(xid
, &oparms
, &srch_path
, &oplock
, NULL
, NULL
);
339 SMB2_QFS_attr(xid
, tcon
, fid
.persistent_fid
, fid
.volatile_fid
,
340 FS_ATTRIBUTE_INFORMATION
);
341 SMB2_QFS_attr(xid
, tcon
, fid
.persistent_fid
, fid
.volatile_fid
,
342 FS_DEVICE_INFORMATION
);
343 SMB2_close(xid
, tcon
, fid
.persistent_fid
, fid
.volatile_fid
);
348 smb2_is_path_accessible(const unsigned int xid
, struct cifs_tcon
*tcon
,
349 struct cifs_sb_info
*cifs_sb
, const char *full_path
)
353 __u8 oplock
= SMB2_OPLOCK_LEVEL_NONE
;
354 struct cifs_open_parms oparms
;
357 utf16_path
= cifs_convert_path_to_utf16(full_path
, cifs_sb
);
362 oparms
.desired_access
= FILE_READ_ATTRIBUTES
;
363 oparms
.disposition
= FILE_OPEN
;
364 oparms
.create_options
= 0;
366 oparms
.reconnect
= false;
368 rc
= SMB2_open(xid
, &oparms
, utf16_path
, &oplock
, NULL
, NULL
);
374 rc
= SMB2_close(xid
, tcon
, fid
.persistent_fid
, fid
.volatile_fid
);
380 smb2_get_srv_inum(const unsigned int xid
, struct cifs_tcon
*tcon
,
381 struct cifs_sb_info
*cifs_sb
, const char *full_path
,
382 u64
*uniqueid
, FILE_ALL_INFO
*data
)
384 *uniqueid
= le64_to_cpu(data
->IndexNumber
);
389 smb2_query_file_info(const unsigned int xid
, struct cifs_tcon
*tcon
,
390 struct cifs_fid
*fid
, FILE_ALL_INFO
*data
)
393 struct smb2_file_all_info
*smb2_data
;
395 smb2_data
= kzalloc(sizeof(struct smb2_file_all_info
) + PATH_MAX
* 2,
397 if (smb2_data
== NULL
)
400 rc
= SMB2_query_info(xid
, tcon
, fid
->persistent_fid
, fid
->volatile_fid
,
403 move_smb2_info_to_cifs(data
, smb2_data
);
409 smb2_can_echo(struct TCP_Server_Info
*server
)
411 return server
->echoes
;
415 smb2_clear_stats(struct cifs_tcon
*tcon
)
417 #ifdef CONFIG_CIFS_STATS
419 for (i
= 0; i
< NUMBER_OF_SMB2_COMMANDS
; i
++) {
420 atomic_set(&tcon
->stats
.smb2_stats
.smb2_com_sent
[i
], 0);
421 atomic_set(&tcon
->stats
.smb2_stats
.smb2_com_failed
[i
], 0);
427 smb2_dump_share_caps(struct seq_file
*m
, struct cifs_tcon
*tcon
)
429 seq_puts(m
, "\n\tShare Capabilities:");
430 if (tcon
->capabilities
& SMB2_SHARE_CAP_DFS
)
431 seq_puts(m
, " DFS,");
432 if (tcon
->capabilities
& SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY
)
433 seq_puts(m
, " CONTINUOUS AVAILABILITY,");
434 if (tcon
->capabilities
& SMB2_SHARE_CAP_SCALEOUT
)
435 seq_puts(m
, " SCALEOUT,");
436 if (tcon
->capabilities
& SMB2_SHARE_CAP_CLUSTER
)
437 seq_puts(m
, " CLUSTER,");
438 if (tcon
->capabilities
& SMB2_SHARE_CAP_ASYMMETRIC
)
439 seq_puts(m
, " ASYMMETRIC,");
440 if (tcon
->capabilities
== 0)
441 seq_puts(m
, " None");
442 if (tcon
->ss_flags
& SSINFO_FLAGS_ALIGNED_DEVICE
)
443 seq_puts(m
, " Aligned,");
444 if (tcon
->ss_flags
& SSINFO_FLAGS_PARTITION_ALIGNED_ON_DEVICE
)
445 seq_puts(m
, " Partition Aligned,");
446 if (tcon
->ss_flags
& SSINFO_FLAGS_NO_SEEK_PENALTY
)
447 seq_puts(m
, " SSD,");
448 if (tcon
->ss_flags
& SSINFO_FLAGS_TRIM_ENABLED
)
449 seq_puts(m
, " TRIM-support,");
451 seq_printf(m
, "\tShare Flags: 0x%x", tcon
->share_flags
);
452 if (tcon
->perf_sector_size
)
453 seq_printf(m
, "\tOptimal sector size: 0x%x",
454 tcon
->perf_sector_size
);
458 smb2_print_stats(struct seq_file
*m
, struct cifs_tcon
*tcon
)
460 #ifdef CONFIG_CIFS_STATS
461 atomic_t
*sent
= tcon
->stats
.smb2_stats
.smb2_com_sent
;
462 atomic_t
*failed
= tcon
->stats
.smb2_stats
.smb2_com_failed
;
463 seq_printf(m
, "\nNegotiates: %d sent %d failed",
464 atomic_read(&sent
[SMB2_NEGOTIATE_HE
]),
465 atomic_read(&failed
[SMB2_NEGOTIATE_HE
]));
466 seq_printf(m
, "\nSessionSetups: %d sent %d failed",
467 atomic_read(&sent
[SMB2_SESSION_SETUP_HE
]),
468 atomic_read(&failed
[SMB2_SESSION_SETUP_HE
]));
469 seq_printf(m
, "\nLogoffs: %d sent %d failed",
470 atomic_read(&sent
[SMB2_LOGOFF_HE
]),
471 atomic_read(&failed
[SMB2_LOGOFF_HE
]));
472 seq_printf(m
, "\nTreeConnects: %d sent %d failed",
473 atomic_read(&sent
[SMB2_TREE_CONNECT_HE
]),
474 atomic_read(&failed
[SMB2_TREE_CONNECT_HE
]));
475 seq_printf(m
, "\nTreeDisconnects: %d sent %d failed",
476 atomic_read(&sent
[SMB2_TREE_DISCONNECT_HE
]),
477 atomic_read(&failed
[SMB2_TREE_DISCONNECT_HE
]));
478 seq_printf(m
, "\nCreates: %d sent %d failed",
479 atomic_read(&sent
[SMB2_CREATE_HE
]),
480 atomic_read(&failed
[SMB2_CREATE_HE
]));
481 seq_printf(m
, "\nCloses: %d sent %d failed",
482 atomic_read(&sent
[SMB2_CLOSE_HE
]),
483 atomic_read(&failed
[SMB2_CLOSE_HE
]));
484 seq_printf(m
, "\nFlushes: %d sent %d failed",
485 atomic_read(&sent
[SMB2_FLUSH_HE
]),
486 atomic_read(&failed
[SMB2_FLUSH_HE
]));
487 seq_printf(m
, "\nReads: %d sent %d failed",
488 atomic_read(&sent
[SMB2_READ_HE
]),
489 atomic_read(&failed
[SMB2_READ_HE
]));
490 seq_printf(m
, "\nWrites: %d sent %d failed",
491 atomic_read(&sent
[SMB2_WRITE_HE
]),
492 atomic_read(&failed
[SMB2_WRITE_HE
]));
493 seq_printf(m
, "\nLocks: %d sent %d failed",
494 atomic_read(&sent
[SMB2_LOCK_HE
]),
495 atomic_read(&failed
[SMB2_LOCK_HE
]));
496 seq_printf(m
, "\nIOCTLs: %d sent %d failed",
497 atomic_read(&sent
[SMB2_IOCTL_HE
]),
498 atomic_read(&failed
[SMB2_IOCTL_HE
]));
499 seq_printf(m
, "\nCancels: %d sent %d failed",
500 atomic_read(&sent
[SMB2_CANCEL_HE
]),
501 atomic_read(&failed
[SMB2_CANCEL_HE
]));
502 seq_printf(m
, "\nEchos: %d sent %d failed",
503 atomic_read(&sent
[SMB2_ECHO_HE
]),
504 atomic_read(&failed
[SMB2_ECHO_HE
]));
505 seq_printf(m
, "\nQueryDirectories: %d sent %d failed",
506 atomic_read(&sent
[SMB2_QUERY_DIRECTORY_HE
]),
507 atomic_read(&failed
[SMB2_QUERY_DIRECTORY_HE
]));
508 seq_printf(m
, "\nChangeNotifies: %d sent %d failed",
509 atomic_read(&sent
[SMB2_CHANGE_NOTIFY_HE
]),
510 atomic_read(&failed
[SMB2_CHANGE_NOTIFY_HE
]));
511 seq_printf(m
, "\nQueryInfos: %d sent %d failed",
512 atomic_read(&sent
[SMB2_QUERY_INFO_HE
]),
513 atomic_read(&failed
[SMB2_QUERY_INFO_HE
]));
514 seq_printf(m
, "\nSetInfos: %d sent %d failed",
515 atomic_read(&sent
[SMB2_SET_INFO_HE
]),
516 atomic_read(&failed
[SMB2_SET_INFO_HE
]));
517 seq_printf(m
, "\nOplockBreaks: %d sent %d failed",
518 atomic_read(&sent
[SMB2_OPLOCK_BREAK_HE
]),
519 atomic_read(&failed
[SMB2_OPLOCK_BREAK_HE
]));
524 smb2_set_fid(struct cifsFileInfo
*cfile
, struct cifs_fid
*fid
, __u32 oplock
)
526 struct cifsInodeInfo
*cinode
= CIFS_I(cfile
->dentry
->d_inode
);
527 struct TCP_Server_Info
*server
= tlink_tcon(cfile
->tlink
)->ses
->server
;
529 cfile
->fid
.persistent_fid
= fid
->persistent_fid
;
530 cfile
->fid
.volatile_fid
= fid
->volatile_fid
;
531 server
->ops
->set_oplock_level(cinode
, oplock
, fid
->epoch
,
533 cinode
->can_cache_brlcks
= CIFS_CACHE_WRITE(cinode
);
537 smb2_close_file(const unsigned int xid
, struct cifs_tcon
*tcon
,
538 struct cifs_fid
*fid
)
540 SMB2_close(xid
, tcon
, fid
->persistent_fid
, fid
->volatile_fid
);
544 SMB2_request_res_key(const unsigned int xid
, struct cifs_tcon
*tcon
,
545 u64 persistent_fid
, u64 volatile_fid
,
546 struct copychunk_ioctl
*pcchunk
)
549 unsigned int ret_data_len
;
550 struct resume_key_req
*res_key
;
552 rc
= SMB2_ioctl(xid
, tcon
, persistent_fid
, volatile_fid
,
553 FSCTL_SRV_REQUEST_RESUME_KEY
, true /* is_fsctl */,
554 NULL
, 0 /* no input */,
555 (char **)&res_key
, &ret_data_len
);
558 cifs_dbg(VFS
, "refcpy ioctl error %d getting resume key\n", rc
);
559 goto req_res_key_exit
;
561 if (ret_data_len
< sizeof(struct resume_key_req
)) {
562 cifs_dbg(VFS
, "Invalid refcopy resume key length\n");
564 goto req_res_key_exit
;
566 memcpy(pcchunk
->SourceKey
, res_key
->ResumeKey
, COPY_CHUNK_RES_KEY_SIZE
);
574 smb2_clone_range(const unsigned int xid
,
575 struct cifsFileInfo
*srcfile
,
576 struct cifsFileInfo
*trgtfile
, u64 src_off
,
577 u64 len
, u64 dest_off
)
580 unsigned int ret_data_len
;
581 struct copychunk_ioctl
*pcchunk
;
582 struct copychunk_ioctl_rsp
*retbuf
= NULL
;
583 struct cifs_tcon
*tcon
;
584 int chunks_copied
= 0;
585 bool chunk_sizes_updated
= false;
587 pcchunk
= kmalloc(sizeof(struct copychunk_ioctl
), GFP_KERNEL
);
592 cifs_dbg(FYI
, "in smb2_clone_range - about to call request res key\n");
593 /* Request a key from the server to identify the source of the copy */
594 rc
= SMB2_request_res_key(xid
, tlink_tcon(srcfile
->tlink
),
595 srcfile
->fid
.persistent_fid
,
596 srcfile
->fid
.volatile_fid
, pcchunk
);
598 /* Note: request_res_key sets res_key null only if rc !=0 */
602 /* For now array only one chunk long, will make more flexible later */
603 pcchunk
->ChunkCount
= __constant_cpu_to_le32(1);
604 pcchunk
->Reserved
= 0;
605 pcchunk
->Reserved2
= 0;
607 tcon
= tlink_tcon(trgtfile
->tlink
);
610 pcchunk
->SourceOffset
= cpu_to_le64(src_off
);
611 pcchunk
->TargetOffset
= cpu_to_le64(dest_off
);
613 cpu_to_le32(min_t(u32
, len
, tcon
->max_bytes_chunk
));
615 /* Request server copy to target from src identified by key */
616 rc
= SMB2_ioctl(xid
, tcon
, trgtfile
->fid
.persistent_fid
,
617 trgtfile
->fid
.volatile_fid
, FSCTL_SRV_COPYCHUNK_WRITE
,
618 true /* is_fsctl */, (char *)pcchunk
,
619 sizeof(struct copychunk_ioctl
), (char **)&retbuf
,
623 sizeof(struct copychunk_ioctl_rsp
)) {
624 cifs_dbg(VFS
, "invalid cchunk response size\n");
628 if (retbuf
->TotalBytesWritten
== 0) {
629 cifs_dbg(FYI
, "no bytes copied\n");
634 * Check if server claimed to write more than we asked
636 if (le32_to_cpu(retbuf
->TotalBytesWritten
) >
637 le32_to_cpu(pcchunk
->Length
)) {
638 cifs_dbg(VFS
, "invalid copy chunk response\n");
642 if (le32_to_cpu(retbuf
->ChunksWritten
) != 1) {
643 cifs_dbg(VFS
, "invalid num chunks written\n");
649 src_off
+= le32_to_cpu(retbuf
->TotalBytesWritten
);
650 dest_off
+= le32_to_cpu(retbuf
->TotalBytesWritten
);
651 len
-= le32_to_cpu(retbuf
->TotalBytesWritten
);
653 cifs_dbg(FYI
, "Chunks %d PartialChunk %d Total %d\n",
654 le32_to_cpu(retbuf
->ChunksWritten
),
655 le32_to_cpu(retbuf
->ChunkBytesWritten
),
656 le32_to_cpu(retbuf
->TotalBytesWritten
));
657 } else if (rc
== -EINVAL
) {
658 if (ret_data_len
!= sizeof(struct copychunk_ioctl_rsp
))
661 cifs_dbg(FYI
, "MaxChunks %d BytesChunk %d MaxCopy %d\n",
662 le32_to_cpu(retbuf
->ChunksWritten
),
663 le32_to_cpu(retbuf
->ChunkBytesWritten
),
664 le32_to_cpu(retbuf
->TotalBytesWritten
));
667 * Check if this is the first request using these sizes,
668 * (ie check if copy succeed once with original sizes
669 * and check if the server gave us different sizes after
670 * we already updated max sizes on previous request).
671 * if not then why is the server returning an error now
673 if ((chunks_copied
!= 0) || chunk_sizes_updated
)
676 /* Check that server is not asking us to grow size */
677 if (le32_to_cpu(retbuf
->ChunkBytesWritten
) <
678 tcon
->max_bytes_chunk
)
679 tcon
->max_bytes_chunk
=
680 le32_to_cpu(retbuf
->ChunkBytesWritten
);
682 goto cchunk_out
; /* server gave us bogus size */
684 /* No need to change MaxChunks since already set to 1 */
685 chunk_sizes_updated
= true;
695 smb2_flush_file(const unsigned int xid
, struct cifs_tcon
*tcon
,
696 struct cifs_fid
*fid
)
698 return SMB2_flush(xid
, tcon
, fid
->persistent_fid
, fid
->volatile_fid
);
702 smb2_read_data_offset(char *buf
)
704 struct smb2_read_rsp
*rsp
= (struct smb2_read_rsp
*)buf
;
705 return rsp
->DataOffset
;
709 smb2_read_data_length(char *buf
)
711 struct smb2_read_rsp
*rsp
= (struct smb2_read_rsp
*)buf
;
712 return le32_to_cpu(rsp
->DataLength
);
717 smb2_sync_read(const unsigned int xid
, struct cifs_fid
*pfid
,
718 struct cifs_io_parms
*parms
, unsigned int *bytes_read
,
719 char **buf
, int *buf_type
)
721 parms
->persistent_fid
= pfid
->persistent_fid
;
722 parms
->volatile_fid
= pfid
->volatile_fid
;
723 return SMB2_read(xid
, parms
, bytes_read
, buf
, buf_type
);
727 smb2_sync_write(const unsigned int xid
, struct cifs_fid
*pfid
,
728 struct cifs_io_parms
*parms
, unsigned int *written
,
729 struct kvec
*iov
, unsigned long nr_segs
)
732 parms
->persistent_fid
= pfid
->persistent_fid
;
733 parms
->volatile_fid
= pfid
->volatile_fid
;
734 return SMB2_write(xid
, parms
, written
, iov
, nr_segs
);
737 /* Set or clear the SPARSE_FILE attribute based on value passed in setsparse */
738 static bool smb2_set_sparse(const unsigned int xid
, struct cifs_tcon
*tcon
,
739 struct cifsFileInfo
*cfile
, struct inode
*inode
, __u8 setsparse
)
741 struct cifsInodeInfo
*cifsi
;
744 cifsi
= CIFS_I(inode
);
746 /* if file already sparse don't bother setting sparse again */
747 if ((cifsi
->cifsAttrs
& FILE_ATTRIBUTE_SPARSE_FILE
) && setsparse
)
748 return true; /* already sparse */
750 if (!(cifsi
->cifsAttrs
& FILE_ATTRIBUTE_SPARSE_FILE
) && !setsparse
)
751 return true; /* already not sparse */
754 * Can't check for sparse support on share the usual way via the
755 * FS attribute info (FILE_SUPPORTS_SPARSE_FILES) on the share
756 * since Samba server doesn't set the flag on the share, yet
757 * supports the set sparse FSCTL and returns sparse correctly
758 * in the file attributes. If we fail setting sparse though we
759 * mark that server does not support sparse files for this share
760 * to avoid repeatedly sending the unsupported fsctl to server
761 * if the file is repeatedly extended.
763 if (tcon
->broken_sparse_sup
)
766 rc
= SMB2_ioctl(xid
, tcon
, cfile
->fid
.persistent_fid
,
767 cfile
->fid
.volatile_fid
, FSCTL_SET_SPARSE
,
768 true /* is_fctl */, &setsparse
, 1, NULL
, NULL
);
770 tcon
->broken_sparse_sup
= true;
771 cifs_dbg(FYI
, "set sparse rc = %d\n", rc
);
776 cifsi
->cifsAttrs
|= FILE_ATTRIBUTE_SPARSE_FILE
;
778 cifsi
->cifsAttrs
&= (~FILE_ATTRIBUTE_SPARSE_FILE
);
784 smb2_set_file_size(const unsigned int xid
, struct cifs_tcon
*tcon
,
785 struct cifsFileInfo
*cfile
, __u64 size
, bool set_alloc
)
787 __le64 eof
= cpu_to_le64(size
);
791 * If extending file more than one page make sparse. Many Linux fs
792 * make files sparse by default when extending via ftruncate
794 inode
= cfile
->dentry
->d_inode
;
796 if (!set_alloc
&& (size
> inode
->i_size
+ 8192)) {
799 /* whether set sparse succeeds or not, extend the file */
800 smb2_set_sparse(xid
, tcon
, cfile
, inode
, set_sparse
);
803 return SMB2_set_eof(xid
, tcon
, cfile
->fid
.persistent_fid
,
804 cfile
->fid
.volatile_fid
, cfile
->pid
, &eof
, false);
808 smb2_set_compression(const unsigned int xid
, struct cifs_tcon
*tcon
,
809 struct cifsFileInfo
*cfile
)
811 return SMB2_set_compression(xid
, tcon
, cfile
->fid
.persistent_fid
,
812 cfile
->fid
.volatile_fid
);
816 smb2_query_dir_first(const unsigned int xid
, struct cifs_tcon
*tcon
,
817 const char *path
, struct cifs_sb_info
*cifs_sb
,
818 struct cifs_fid
*fid
, __u16 search_flags
,
819 struct cifs_search_info
*srch_inf
)
823 __u8 oplock
= SMB2_OPLOCK_LEVEL_NONE
;
824 struct cifs_open_parms oparms
;
826 utf16_path
= cifs_convert_path_to_utf16(path
, cifs_sb
);
831 oparms
.desired_access
= FILE_READ_ATTRIBUTES
| FILE_READ_DATA
;
832 oparms
.disposition
= FILE_OPEN
;
833 oparms
.create_options
= 0;
835 oparms
.reconnect
= false;
837 rc
= SMB2_open(xid
, &oparms
, utf16_path
, &oplock
, NULL
, NULL
);
840 cifs_dbg(VFS
, "open dir failed\n");
844 srch_inf
->entries_in_buffer
= 0;
845 srch_inf
->index_of_last_entry
= 0;
847 rc
= SMB2_query_directory(xid
, tcon
, fid
->persistent_fid
,
848 fid
->volatile_fid
, 0, srch_inf
);
850 cifs_dbg(VFS
, "query directory failed\n");
851 SMB2_close(xid
, tcon
, fid
->persistent_fid
, fid
->volatile_fid
);
857 smb2_query_dir_next(const unsigned int xid
, struct cifs_tcon
*tcon
,
858 struct cifs_fid
*fid
, __u16 search_flags
,
859 struct cifs_search_info
*srch_inf
)
861 return SMB2_query_directory(xid
, tcon
, fid
->persistent_fid
,
862 fid
->volatile_fid
, 0, srch_inf
);
866 smb2_close_dir(const unsigned int xid
, struct cifs_tcon
*tcon
,
867 struct cifs_fid
*fid
)
869 return SMB2_close(xid
, tcon
, fid
->persistent_fid
, fid
->volatile_fid
);
873 * If we negotiate SMB2 protocol and get STATUS_PENDING - update
874 * the number of credits and return true. Otherwise - return false.
877 smb2_is_status_pending(char *buf
, struct TCP_Server_Info
*server
, int length
)
879 struct smb2_hdr
*hdr
= (struct smb2_hdr
*)buf
;
881 if (hdr
->Status
!= STATUS_PENDING
)
885 spin_lock(&server
->req_lock
);
886 server
->credits
+= le16_to_cpu(hdr
->CreditRequest
);
887 spin_unlock(&server
->req_lock
);
888 wake_up(&server
->request_q
);
895 smb2_oplock_response(struct cifs_tcon
*tcon
, struct cifs_fid
*fid
,
896 struct cifsInodeInfo
*cinode
)
898 if (tcon
->ses
->server
->capabilities
& SMB2_GLOBAL_CAP_LEASING
)
899 return SMB2_lease_break(0, tcon
, cinode
->lease_key
,
900 smb2_get_lease_state(cinode
));
902 return SMB2_oplock_break(0, tcon
, fid
->persistent_fid
,
904 CIFS_CACHE_READ(cinode
) ? 1 : 0);
908 smb2_queryfs(const unsigned int xid
, struct cifs_tcon
*tcon
,
912 __le16 srch_path
= 0; /* Null - open root of share */
913 u8 oplock
= SMB2_OPLOCK_LEVEL_NONE
;
914 struct cifs_open_parms oparms
;
918 oparms
.desired_access
= FILE_READ_ATTRIBUTES
;
919 oparms
.disposition
= FILE_OPEN
;
920 oparms
.create_options
= 0;
922 oparms
.reconnect
= false;
924 rc
= SMB2_open(xid
, &oparms
, &srch_path
, &oplock
, NULL
, NULL
);
927 buf
->f_type
= SMB2_MAGIC_NUMBER
;
928 rc
= SMB2_QFS_info(xid
, tcon
, fid
.persistent_fid
, fid
.volatile_fid
,
930 SMB2_close(xid
, tcon
, fid
.persistent_fid
, fid
.volatile_fid
);
935 smb2_compare_fids(struct cifsFileInfo
*ob1
, struct cifsFileInfo
*ob2
)
937 return ob1
->fid
.persistent_fid
== ob2
->fid
.persistent_fid
&&
938 ob1
->fid
.volatile_fid
== ob2
->fid
.volatile_fid
;
942 smb2_mand_lock(const unsigned int xid
, struct cifsFileInfo
*cfile
, __u64 offset
,
943 __u64 length
, __u32 type
, int lock
, int unlock
, bool wait
)
946 type
= SMB2_LOCKFLAG_UNLOCK
;
947 return SMB2_lock(xid
, tlink_tcon(cfile
->tlink
),
948 cfile
->fid
.persistent_fid
, cfile
->fid
.volatile_fid
,
949 current
->tgid
, length
, offset
, type
, wait
);
953 smb2_get_lease_key(struct inode
*inode
, struct cifs_fid
*fid
)
955 memcpy(fid
->lease_key
, CIFS_I(inode
)->lease_key
, SMB2_LEASE_KEY_SIZE
);
959 smb2_set_lease_key(struct inode
*inode
, struct cifs_fid
*fid
)
961 memcpy(CIFS_I(inode
)->lease_key
, fid
->lease_key
, SMB2_LEASE_KEY_SIZE
);
965 smb2_new_lease_key(struct cifs_fid
*fid
)
967 get_random_bytes(fid
->lease_key
, SMB2_LEASE_KEY_SIZE
);
971 smb2_query_symlink(const unsigned int xid
, struct cifs_tcon
*tcon
,
972 const char *full_path
, char **target_path
,
973 struct cifs_sb_info
*cifs_sb
)
977 __u8 oplock
= SMB2_OPLOCK_LEVEL_NONE
;
978 struct cifs_open_parms oparms
;
980 struct smb2_err_rsp
*err_buf
= NULL
;
981 struct smb2_symlink_err_rsp
*symlink
;
982 unsigned int sub_len
, sub_offset
;
984 cifs_dbg(FYI
, "%s: path: %s\n", __func__
, full_path
);
986 utf16_path
= cifs_convert_path_to_utf16(full_path
, cifs_sb
);
991 oparms
.desired_access
= FILE_READ_ATTRIBUTES
;
992 oparms
.disposition
= FILE_OPEN
;
993 oparms
.create_options
= 0;
995 oparms
.reconnect
= false;
997 rc
= SMB2_open(xid
, &oparms
, utf16_path
, &oplock
, NULL
, &err_buf
);
999 if (!rc
|| !err_buf
) {
1003 /* open must fail on symlink - reset rc */
1005 symlink
= (struct smb2_symlink_err_rsp
*)err_buf
->ErrorData
;
1006 sub_len
= le16_to_cpu(symlink
->SubstituteNameLength
);
1007 sub_offset
= le16_to_cpu(symlink
->SubstituteNameOffset
);
1008 *target_path
= cifs_strndup_from_utf16(
1009 (char *)symlink
->PathBuffer
+ sub_offset
,
1010 sub_len
, true, cifs_sb
->local_nls
);
1011 if (!(*target_path
)) {
1015 convert_delimiter(*target_path
, '/');
1016 cifs_dbg(FYI
, "%s: target path: %s\n", __func__
, *target_path
);
1021 static long smb3_zero_range(struct file
*file
, struct cifs_tcon
*tcon
,
1022 loff_t offset
, loff_t len
, bool keep_size
)
1024 struct inode
*inode
;
1025 struct cifsInodeInfo
*cifsi
;
1026 struct cifsFileInfo
*cfile
= file
->private_data
;
1027 struct file_zero_data_information fsctl_buf
;
1033 inode
= cfile
->dentry
->d_inode
;
1034 cifsi
= CIFS_I(inode
);
1036 /* if file not oplocked can't be sure whether asking to extend size */
1037 if (!CIFS_CACHE_READ(cifsi
))
1038 if (keep_size
== false)
1042 * Must check if file sparse since fallocate -z (zero range) assumes
1043 * non-sparse allocation
1045 if (!(cifsi
->cifsAttrs
& FILE_ATTRIBUTE_SPARSE_FILE
))
1049 * need to make sure we are not asked to extend the file since the SMB3
1050 * fsctl does not change the file size. In the future we could change
1051 * this to zero the first part of the range then set the file size
1052 * which for a non sparse file would zero the newly extended range
1054 if (keep_size
== false)
1055 if (i_size_read(inode
) < offset
+ len
)
1058 cifs_dbg(FYI
, "offset %lld len %lld", offset
, len
);
1060 fsctl_buf
.FileOffset
= cpu_to_le64(offset
);
1061 fsctl_buf
.BeyondFinalZero
= cpu_to_le64(offset
+ len
);
1063 rc
= SMB2_ioctl(xid
, tcon
, cfile
->fid
.persistent_fid
,
1064 cfile
->fid
.volatile_fid
, FSCTL_SET_ZERO_DATA
,
1065 true /* is_fctl */, (char *)&fsctl_buf
,
1066 sizeof(struct file_zero_data_information
), NULL
, NULL
);
1071 static long smb3_punch_hole(struct file
*file
, struct cifs_tcon
*tcon
,
1072 loff_t offset
, loff_t len
)
1074 struct inode
*inode
;
1075 struct cifsInodeInfo
*cifsi
;
1076 struct cifsFileInfo
*cfile
= file
->private_data
;
1077 struct file_zero_data_information fsctl_buf
;
1080 __u8 set_sparse
= 1;
1084 inode
= cfile
->dentry
->d_inode
;
1085 cifsi
= CIFS_I(inode
);
1087 /* Need to make file sparse, if not already, before freeing range. */
1088 /* Consider adding equivalent for compressed since it could also work */
1089 if (!smb2_set_sparse(xid
, tcon
, cfile
, inode
, set_sparse
))
1092 cifs_dbg(FYI
, "offset %lld len %lld", offset
, len
);
1094 fsctl_buf
.FileOffset
= cpu_to_le64(offset
);
1095 fsctl_buf
.BeyondFinalZero
= cpu_to_le64(offset
+ len
);
1097 rc
= SMB2_ioctl(xid
, tcon
, cfile
->fid
.persistent_fid
,
1098 cfile
->fid
.volatile_fid
, FSCTL_SET_ZERO_DATA
,
1099 true /* is_fctl */, (char *)&fsctl_buf
,
1100 sizeof(struct file_zero_data_information
), NULL
, NULL
);
1105 static long smb3_fallocate(struct file
*file
, struct cifs_tcon
*tcon
, int mode
,
1106 loff_t off
, loff_t len
)
1108 /* KEEP_SIZE already checked for by do_fallocate */
1109 if (mode
& FALLOC_FL_PUNCH_HOLE
)
1110 return smb3_punch_hole(file
, tcon
, off
, len
);
1111 else if (mode
& FALLOC_FL_ZERO_RANGE
) {
1112 if (mode
& FALLOC_FL_KEEP_SIZE
)
1113 return smb3_zero_range(file
, tcon
, off
, len
, true);
1114 return smb3_zero_range(file
, tcon
, off
, len
, false);
1121 smb2_downgrade_oplock(struct TCP_Server_Info
*server
,
1122 struct cifsInodeInfo
*cinode
, bool set_level2
)
1125 server
->ops
->set_oplock_level(cinode
, SMB2_OPLOCK_LEVEL_II
,
1128 server
->ops
->set_oplock_level(cinode
, 0, 0, NULL
);
1132 smb2_set_oplock_level(struct cifsInodeInfo
*cinode
, __u32 oplock
,
1133 unsigned int epoch
, bool *purge_cache
)
1136 if (oplock
== SMB2_OPLOCK_LEVEL_NOCHANGE
)
1138 if (oplock
== SMB2_OPLOCK_LEVEL_BATCH
) {
1139 cinode
->oplock
= CIFS_CACHE_RHW_FLG
;
1140 cifs_dbg(FYI
, "Batch Oplock granted on inode %p\n",
1141 &cinode
->vfs_inode
);
1142 } else if (oplock
== SMB2_OPLOCK_LEVEL_EXCLUSIVE
) {
1143 cinode
->oplock
= CIFS_CACHE_RW_FLG
;
1144 cifs_dbg(FYI
, "Exclusive Oplock granted on inode %p\n",
1145 &cinode
->vfs_inode
);
1146 } else if (oplock
== SMB2_OPLOCK_LEVEL_II
) {
1147 cinode
->oplock
= CIFS_CACHE_READ_FLG
;
1148 cifs_dbg(FYI
, "Level II Oplock granted on inode %p\n",
1149 &cinode
->vfs_inode
);
1155 smb21_set_oplock_level(struct cifsInodeInfo
*cinode
, __u32 oplock
,
1156 unsigned int epoch
, bool *purge_cache
)
1158 char message
[5] = {0};
1161 if (oplock
== SMB2_OPLOCK_LEVEL_NOCHANGE
)
1165 if (oplock
& SMB2_LEASE_READ_CACHING_HE
) {
1166 cinode
->oplock
|= CIFS_CACHE_READ_FLG
;
1167 strcat(message
, "R");
1169 if (oplock
& SMB2_LEASE_HANDLE_CACHING_HE
) {
1170 cinode
->oplock
|= CIFS_CACHE_HANDLE_FLG
;
1171 strcat(message
, "H");
1173 if (oplock
& SMB2_LEASE_WRITE_CACHING_HE
) {
1174 cinode
->oplock
|= CIFS_CACHE_WRITE_FLG
;
1175 strcat(message
, "W");
1177 if (!cinode
->oplock
)
1178 strcat(message
, "None");
1179 cifs_dbg(FYI
, "%s Lease granted on inode %p\n", message
,
1180 &cinode
->vfs_inode
);
1184 smb3_set_oplock_level(struct cifsInodeInfo
*cinode
, __u32 oplock
,
1185 unsigned int epoch
, bool *purge_cache
)
1187 unsigned int old_oplock
= cinode
->oplock
;
1189 smb21_set_oplock_level(cinode
, oplock
, epoch
, purge_cache
);
1192 *purge_cache
= false;
1193 if (old_oplock
== CIFS_CACHE_READ_FLG
) {
1194 if (cinode
->oplock
== CIFS_CACHE_READ_FLG
&&
1195 (epoch
- cinode
->epoch
> 0))
1196 *purge_cache
= true;
1197 else if (cinode
->oplock
== CIFS_CACHE_RH_FLG
&&
1198 (epoch
- cinode
->epoch
> 1))
1199 *purge_cache
= true;
1200 else if (cinode
->oplock
== CIFS_CACHE_RHW_FLG
&&
1201 (epoch
- cinode
->epoch
> 1))
1202 *purge_cache
= true;
1203 else if (cinode
->oplock
== 0 &&
1204 (epoch
- cinode
->epoch
> 0))
1205 *purge_cache
= true;
1206 } else if (old_oplock
== CIFS_CACHE_RH_FLG
) {
1207 if (cinode
->oplock
== CIFS_CACHE_RH_FLG
&&
1208 (epoch
- cinode
->epoch
> 0))
1209 *purge_cache
= true;
1210 else if (cinode
->oplock
== CIFS_CACHE_RHW_FLG
&&
1211 (epoch
- cinode
->epoch
> 1))
1212 *purge_cache
= true;
1214 cinode
->epoch
= epoch
;
1219 smb2_is_read_op(__u32 oplock
)
1221 return oplock
== SMB2_OPLOCK_LEVEL_II
;
1225 smb21_is_read_op(__u32 oplock
)
1227 return (oplock
& SMB2_LEASE_READ_CACHING_HE
) &&
1228 !(oplock
& SMB2_LEASE_WRITE_CACHING_HE
);
1232 map_oplock_to_lease(u8 oplock
)
1234 if (oplock
== SMB2_OPLOCK_LEVEL_EXCLUSIVE
)
1235 return SMB2_LEASE_WRITE_CACHING
| SMB2_LEASE_READ_CACHING
;
1236 else if (oplock
== SMB2_OPLOCK_LEVEL_II
)
1237 return SMB2_LEASE_READ_CACHING
;
1238 else if (oplock
== SMB2_OPLOCK_LEVEL_BATCH
)
1239 return SMB2_LEASE_HANDLE_CACHING
| SMB2_LEASE_READ_CACHING
|
1240 SMB2_LEASE_WRITE_CACHING
;
1245 smb2_create_lease_buf(u8
*lease_key
, u8 oplock
)
1247 struct create_lease
*buf
;
1249 buf
= kzalloc(sizeof(struct create_lease
), GFP_KERNEL
);
1253 buf
->lcontext
.LeaseKeyLow
= cpu_to_le64(*((u64
*)lease_key
));
1254 buf
->lcontext
.LeaseKeyHigh
= cpu_to_le64(*((u64
*)(lease_key
+ 8)));
1255 buf
->lcontext
.LeaseState
= map_oplock_to_lease(oplock
);
1257 buf
->ccontext
.DataOffset
= cpu_to_le16(offsetof
1258 (struct create_lease
, lcontext
));
1259 buf
->ccontext
.DataLength
= cpu_to_le32(sizeof(struct lease_context
));
1260 buf
->ccontext
.NameOffset
= cpu_to_le16(offsetof
1261 (struct create_lease
, Name
));
1262 buf
->ccontext
.NameLength
= cpu_to_le16(4);
1263 /* SMB2_CREATE_REQUEST_LEASE is "RqLs" */
1272 smb3_create_lease_buf(u8
*lease_key
, u8 oplock
)
1274 struct create_lease_v2
*buf
;
1276 buf
= kzalloc(sizeof(struct create_lease_v2
), GFP_KERNEL
);
1280 buf
->lcontext
.LeaseKeyLow
= cpu_to_le64(*((u64
*)lease_key
));
1281 buf
->lcontext
.LeaseKeyHigh
= cpu_to_le64(*((u64
*)(lease_key
+ 8)));
1282 buf
->lcontext
.LeaseState
= map_oplock_to_lease(oplock
);
1284 buf
->ccontext
.DataOffset
= cpu_to_le16(offsetof
1285 (struct create_lease_v2
, lcontext
));
1286 buf
->ccontext
.DataLength
= cpu_to_le32(sizeof(struct lease_context_v2
));
1287 buf
->ccontext
.NameOffset
= cpu_to_le16(offsetof
1288 (struct create_lease_v2
, Name
));
1289 buf
->ccontext
.NameLength
= cpu_to_le16(4);
1290 /* SMB2_CREATE_REQUEST_LEASE is "RqLs" */
1299 smb2_parse_lease_buf(void *buf
, unsigned int *epoch
)
1301 struct create_lease
*lc
= (struct create_lease
*)buf
;
1303 *epoch
= 0; /* not used */
1304 if (lc
->lcontext
.LeaseFlags
& SMB2_LEASE_FLAG_BREAK_IN_PROGRESS
)
1305 return SMB2_OPLOCK_LEVEL_NOCHANGE
;
1306 return le32_to_cpu(lc
->lcontext
.LeaseState
);
1310 smb3_parse_lease_buf(void *buf
, unsigned int *epoch
)
1312 struct create_lease_v2
*lc
= (struct create_lease_v2
*)buf
;
1314 *epoch
= le16_to_cpu(lc
->lcontext
.Epoch
);
1315 if (lc
->lcontext
.LeaseFlags
& SMB2_LEASE_FLAG_BREAK_IN_PROGRESS
)
1316 return SMB2_OPLOCK_LEVEL_NOCHANGE
;
1317 return le32_to_cpu(lc
->lcontext
.LeaseState
);
1321 smb2_wp_retry_size(struct inode
*inode
)
1323 return min_t(unsigned int, CIFS_SB(inode
->i_sb
)->wsize
,
1324 SMB2_MAX_BUFFER_SIZE
);
1328 smb2_dir_needs_close(struct cifsFileInfo
*cfile
)
1330 return !cfile
->invalidHandle
;
1333 struct smb_version_operations smb20_operations
= {
1334 .compare_fids
= smb2_compare_fids
,
1335 .setup_request
= smb2_setup_request
,
1336 .setup_async_request
= smb2_setup_async_request
,
1337 .check_receive
= smb2_check_receive
,
1338 .add_credits
= smb2_add_credits
,
1339 .set_credits
= smb2_set_credits
,
1340 .get_credits_field
= smb2_get_credits_field
,
1341 .get_credits
= smb2_get_credits
,
1342 .wait_mtu_credits
= cifs_wait_mtu_credits
,
1343 .get_next_mid
= smb2_get_next_mid
,
1344 .read_data_offset
= smb2_read_data_offset
,
1345 .read_data_length
= smb2_read_data_length
,
1346 .map_error
= map_smb2_to_linux_error
,
1347 .find_mid
= smb2_find_mid
,
1348 .check_message
= smb2_check_message
,
1349 .dump_detail
= smb2_dump_detail
,
1350 .clear_stats
= smb2_clear_stats
,
1351 .print_stats
= smb2_print_stats
,
1352 .is_oplock_break
= smb2_is_valid_oplock_break
,
1353 .downgrade_oplock
= smb2_downgrade_oplock
,
1354 .need_neg
= smb2_need_neg
,
1355 .negotiate
= smb2_negotiate
,
1356 .negotiate_wsize
= smb2_negotiate_wsize
,
1357 .negotiate_rsize
= smb2_negotiate_rsize
,
1358 .sess_setup
= SMB2_sess_setup
,
1359 .logoff
= SMB2_logoff
,
1360 .tree_connect
= SMB2_tcon
,
1361 .tree_disconnect
= SMB2_tdis
,
1362 .qfs_tcon
= smb2_qfs_tcon
,
1363 .is_path_accessible
= smb2_is_path_accessible
,
1364 .can_echo
= smb2_can_echo
,
1366 .query_path_info
= smb2_query_path_info
,
1367 .get_srv_inum
= smb2_get_srv_inum
,
1368 .query_file_info
= smb2_query_file_info
,
1369 .set_path_size
= smb2_set_path_size
,
1370 .set_file_size
= smb2_set_file_size
,
1371 .set_file_info
= smb2_set_file_info
,
1372 .set_compression
= smb2_set_compression
,
1373 .mkdir
= smb2_mkdir
,
1374 .mkdir_setinfo
= smb2_mkdir_setinfo
,
1375 .rmdir
= smb2_rmdir
,
1376 .unlink
= smb2_unlink
,
1377 .rename
= smb2_rename_path
,
1378 .create_hardlink
= smb2_create_hardlink
,
1379 .query_symlink
= smb2_query_symlink
,
1380 .open
= smb2_open_file
,
1381 .set_fid
= smb2_set_fid
,
1382 .close
= smb2_close_file
,
1383 .flush
= smb2_flush_file
,
1384 .async_readv
= smb2_async_readv
,
1385 .async_writev
= smb2_async_writev
,
1386 .sync_read
= smb2_sync_read
,
1387 .sync_write
= smb2_sync_write
,
1388 .query_dir_first
= smb2_query_dir_first
,
1389 .query_dir_next
= smb2_query_dir_next
,
1390 .close_dir
= smb2_close_dir
,
1391 .calc_smb_size
= smb2_calc_size
,
1392 .is_status_pending
= smb2_is_status_pending
,
1393 .oplock_response
= smb2_oplock_response
,
1394 .queryfs
= smb2_queryfs
,
1395 .mand_lock
= smb2_mand_lock
,
1396 .mand_unlock_range
= smb2_unlock_range
,
1397 .push_mand_locks
= smb2_push_mandatory_locks
,
1398 .get_lease_key
= smb2_get_lease_key
,
1399 .set_lease_key
= smb2_set_lease_key
,
1400 .new_lease_key
= smb2_new_lease_key
,
1401 .calc_signature
= smb2_calc_signature
,
1402 .is_read_op
= smb2_is_read_op
,
1403 .set_oplock_level
= smb2_set_oplock_level
,
1404 .create_lease_buf
= smb2_create_lease_buf
,
1405 .parse_lease_buf
= smb2_parse_lease_buf
,
1406 .clone_range
= smb2_clone_range
,
1407 .wp_retry_size
= smb2_wp_retry_size
,
1408 .dir_needs_close
= smb2_dir_needs_close
,
1411 struct smb_version_operations smb21_operations
= {
1412 .compare_fids
= smb2_compare_fids
,
1413 .setup_request
= smb2_setup_request
,
1414 .setup_async_request
= smb2_setup_async_request
,
1415 .check_receive
= smb2_check_receive
,
1416 .add_credits
= smb2_add_credits
,
1417 .set_credits
= smb2_set_credits
,
1418 .get_credits_field
= smb2_get_credits_field
,
1419 .get_credits
= smb2_get_credits
,
1420 .wait_mtu_credits
= smb2_wait_mtu_credits
,
1421 .get_next_mid
= smb2_get_next_mid
,
1422 .read_data_offset
= smb2_read_data_offset
,
1423 .read_data_length
= smb2_read_data_length
,
1424 .map_error
= map_smb2_to_linux_error
,
1425 .find_mid
= smb2_find_mid
,
1426 .check_message
= smb2_check_message
,
1427 .dump_detail
= smb2_dump_detail
,
1428 .clear_stats
= smb2_clear_stats
,
1429 .print_stats
= smb2_print_stats
,
1430 .is_oplock_break
= smb2_is_valid_oplock_break
,
1431 .downgrade_oplock
= smb2_downgrade_oplock
,
1432 .need_neg
= smb2_need_neg
,
1433 .negotiate
= smb2_negotiate
,
1434 .negotiate_wsize
= smb2_negotiate_wsize
,
1435 .negotiate_rsize
= smb2_negotiate_rsize
,
1436 .sess_setup
= SMB2_sess_setup
,
1437 .logoff
= SMB2_logoff
,
1438 .tree_connect
= SMB2_tcon
,
1439 .tree_disconnect
= SMB2_tdis
,
1440 .qfs_tcon
= smb2_qfs_tcon
,
1441 .is_path_accessible
= smb2_is_path_accessible
,
1442 .can_echo
= smb2_can_echo
,
1444 .query_path_info
= smb2_query_path_info
,
1445 .get_srv_inum
= smb2_get_srv_inum
,
1446 .query_file_info
= smb2_query_file_info
,
1447 .set_path_size
= smb2_set_path_size
,
1448 .set_file_size
= smb2_set_file_size
,
1449 .set_file_info
= smb2_set_file_info
,
1450 .set_compression
= smb2_set_compression
,
1451 .mkdir
= smb2_mkdir
,
1452 .mkdir_setinfo
= smb2_mkdir_setinfo
,
1453 .rmdir
= smb2_rmdir
,
1454 .unlink
= smb2_unlink
,
1455 .rename
= smb2_rename_path
,
1456 .create_hardlink
= smb2_create_hardlink
,
1457 .query_symlink
= smb2_query_symlink
,
1458 .query_mf_symlink
= smb3_query_mf_symlink
,
1459 .create_mf_symlink
= smb3_create_mf_symlink
,
1460 .open
= smb2_open_file
,
1461 .set_fid
= smb2_set_fid
,
1462 .close
= smb2_close_file
,
1463 .flush
= smb2_flush_file
,
1464 .async_readv
= smb2_async_readv
,
1465 .async_writev
= smb2_async_writev
,
1466 .sync_read
= smb2_sync_read
,
1467 .sync_write
= smb2_sync_write
,
1468 .query_dir_first
= smb2_query_dir_first
,
1469 .query_dir_next
= smb2_query_dir_next
,
1470 .close_dir
= smb2_close_dir
,
1471 .calc_smb_size
= smb2_calc_size
,
1472 .is_status_pending
= smb2_is_status_pending
,
1473 .oplock_response
= smb2_oplock_response
,
1474 .queryfs
= smb2_queryfs
,
1475 .mand_lock
= smb2_mand_lock
,
1476 .mand_unlock_range
= smb2_unlock_range
,
1477 .push_mand_locks
= smb2_push_mandatory_locks
,
1478 .get_lease_key
= smb2_get_lease_key
,
1479 .set_lease_key
= smb2_set_lease_key
,
1480 .new_lease_key
= smb2_new_lease_key
,
1481 .calc_signature
= smb2_calc_signature
,
1482 .is_read_op
= smb21_is_read_op
,
1483 .set_oplock_level
= smb21_set_oplock_level
,
1484 .create_lease_buf
= smb2_create_lease_buf
,
1485 .parse_lease_buf
= smb2_parse_lease_buf
,
1486 .clone_range
= smb2_clone_range
,
1487 .wp_retry_size
= smb2_wp_retry_size
,
1488 .dir_needs_close
= smb2_dir_needs_close
,
1491 struct smb_version_operations smb30_operations
= {
1492 .compare_fids
= smb2_compare_fids
,
1493 .setup_request
= smb2_setup_request
,
1494 .setup_async_request
= smb2_setup_async_request
,
1495 .check_receive
= smb2_check_receive
,
1496 .add_credits
= smb2_add_credits
,
1497 .set_credits
= smb2_set_credits
,
1498 .get_credits_field
= smb2_get_credits_field
,
1499 .get_credits
= smb2_get_credits
,
1500 .wait_mtu_credits
= smb2_wait_mtu_credits
,
1501 .get_next_mid
= smb2_get_next_mid
,
1502 .read_data_offset
= smb2_read_data_offset
,
1503 .read_data_length
= smb2_read_data_length
,
1504 .map_error
= map_smb2_to_linux_error
,
1505 .find_mid
= smb2_find_mid
,
1506 .check_message
= smb2_check_message
,
1507 .dump_detail
= smb2_dump_detail
,
1508 .clear_stats
= smb2_clear_stats
,
1509 .print_stats
= smb2_print_stats
,
1510 .dump_share_caps
= smb2_dump_share_caps
,
1511 .is_oplock_break
= smb2_is_valid_oplock_break
,
1512 .downgrade_oplock
= smb2_downgrade_oplock
,
1513 .need_neg
= smb2_need_neg
,
1514 .negotiate
= smb2_negotiate
,
1515 .negotiate_wsize
= smb2_negotiate_wsize
,
1516 .negotiate_rsize
= smb2_negotiate_rsize
,
1517 .sess_setup
= SMB2_sess_setup
,
1518 .logoff
= SMB2_logoff
,
1519 .tree_connect
= SMB2_tcon
,
1520 .tree_disconnect
= SMB2_tdis
,
1521 .qfs_tcon
= smb3_qfs_tcon
,
1522 .is_path_accessible
= smb2_is_path_accessible
,
1523 .can_echo
= smb2_can_echo
,
1525 .query_path_info
= smb2_query_path_info
,
1526 .get_srv_inum
= smb2_get_srv_inum
,
1527 .query_file_info
= smb2_query_file_info
,
1528 .set_path_size
= smb2_set_path_size
,
1529 .set_file_size
= smb2_set_file_size
,
1530 .set_file_info
= smb2_set_file_info
,
1531 .set_compression
= smb2_set_compression
,
1532 .mkdir
= smb2_mkdir
,
1533 .mkdir_setinfo
= smb2_mkdir_setinfo
,
1534 .rmdir
= smb2_rmdir
,
1535 .unlink
= smb2_unlink
,
1536 .rename
= smb2_rename_path
,
1537 .create_hardlink
= smb2_create_hardlink
,
1538 .query_symlink
= smb2_query_symlink
,
1539 .query_mf_symlink
= smb3_query_mf_symlink
,
1540 .create_mf_symlink
= smb3_create_mf_symlink
,
1541 .open
= smb2_open_file
,
1542 .set_fid
= smb2_set_fid
,
1543 .close
= smb2_close_file
,
1544 .flush
= smb2_flush_file
,
1545 .async_readv
= smb2_async_readv
,
1546 .async_writev
= smb2_async_writev
,
1547 .sync_read
= smb2_sync_read
,
1548 .sync_write
= smb2_sync_write
,
1549 .query_dir_first
= smb2_query_dir_first
,
1550 .query_dir_next
= smb2_query_dir_next
,
1551 .close_dir
= smb2_close_dir
,
1552 .calc_smb_size
= smb2_calc_size
,
1553 .is_status_pending
= smb2_is_status_pending
,
1554 .oplock_response
= smb2_oplock_response
,
1555 .queryfs
= smb2_queryfs
,
1556 .mand_lock
= smb2_mand_lock
,
1557 .mand_unlock_range
= smb2_unlock_range
,
1558 .push_mand_locks
= smb2_push_mandatory_locks
,
1559 .get_lease_key
= smb2_get_lease_key
,
1560 .set_lease_key
= smb2_set_lease_key
,
1561 .new_lease_key
= smb2_new_lease_key
,
1562 .generate_signingkey
= generate_smb3signingkey
,
1563 .calc_signature
= smb3_calc_signature
,
1564 .is_read_op
= smb21_is_read_op
,
1565 .set_oplock_level
= smb3_set_oplock_level
,
1566 .create_lease_buf
= smb3_create_lease_buf
,
1567 .parse_lease_buf
= smb3_parse_lease_buf
,
1568 .clone_range
= smb2_clone_range
,
1569 .validate_negotiate
= smb3_validate_negotiate
,
1570 .wp_retry_size
= smb2_wp_retry_size
,
1571 .dir_needs_close
= smb2_dir_needs_close
,
1572 .fallocate
= smb3_fallocate
,
1575 struct smb_version_values smb20_values
= {
1576 .version_string
= SMB20_VERSION_STRING
,
1577 .protocol_id
= SMB20_PROT_ID
,
1578 .req_capabilities
= 0, /* MBZ */
1579 .large_lock_type
= 0,
1580 .exclusive_lock_type
= SMB2_LOCKFLAG_EXCLUSIVE_LOCK
,
1581 .shared_lock_type
= SMB2_LOCKFLAG_SHARED_LOCK
,
1582 .unlock_lock_type
= SMB2_LOCKFLAG_UNLOCK
,
1583 .header_size
= sizeof(struct smb2_hdr
),
1584 .max_header_size
= MAX_SMB2_HDR_SIZE
,
1585 .read_rsp_size
= sizeof(struct smb2_read_rsp
) - 1,
1586 .lock_cmd
= SMB2_LOCK
,
1588 .cap_nt_find
= SMB2_NT_FIND
,
1589 .cap_large_files
= SMB2_LARGE_FILES
,
1590 .signing_enabled
= SMB2_NEGOTIATE_SIGNING_ENABLED
| SMB2_NEGOTIATE_SIGNING_REQUIRED
,
1591 .signing_required
= SMB2_NEGOTIATE_SIGNING_REQUIRED
,
1592 .create_lease_size
= sizeof(struct create_lease
),
1595 struct smb_version_values smb21_values
= {
1596 .version_string
= SMB21_VERSION_STRING
,
1597 .protocol_id
= SMB21_PROT_ID
,
1598 .req_capabilities
= 0, /* MBZ on negotiate req until SMB3 dialect */
1599 .large_lock_type
= 0,
1600 .exclusive_lock_type
= SMB2_LOCKFLAG_EXCLUSIVE_LOCK
,
1601 .shared_lock_type
= SMB2_LOCKFLAG_SHARED_LOCK
,
1602 .unlock_lock_type
= SMB2_LOCKFLAG_UNLOCK
,
1603 .header_size
= sizeof(struct smb2_hdr
),
1604 .max_header_size
= MAX_SMB2_HDR_SIZE
,
1605 .read_rsp_size
= sizeof(struct smb2_read_rsp
) - 1,
1606 .lock_cmd
= SMB2_LOCK
,
1608 .cap_nt_find
= SMB2_NT_FIND
,
1609 .cap_large_files
= SMB2_LARGE_FILES
,
1610 .signing_enabled
= SMB2_NEGOTIATE_SIGNING_ENABLED
| SMB2_NEGOTIATE_SIGNING_REQUIRED
,
1611 .signing_required
= SMB2_NEGOTIATE_SIGNING_REQUIRED
,
1612 .create_lease_size
= sizeof(struct create_lease
),
1615 struct smb_version_values smb30_values
= {
1616 .version_string
= SMB30_VERSION_STRING
,
1617 .protocol_id
= SMB30_PROT_ID
,
1618 .req_capabilities
= SMB2_GLOBAL_CAP_DFS
| SMB2_GLOBAL_CAP_LEASING
| SMB2_GLOBAL_CAP_LARGE_MTU
,
1619 .large_lock_type
= 0,
1620 .exclusive_lock_type
= SMB2_LOCKFLAG_EXCLUSIVE_LOCK
,
1621 .shared_lock_type
= SMB2_LOCKFLAG_SHARED_LOCK
,
1622 .unlock_lock_type
= SMB2_LOCKFLAG_UNLOCK
,
1623 .header_size
= sizeof(struct smb2_hdr
),
1624 .max_header_size
= MAX_SMB2_HDR_SIZE
,
1625 .read_rsp_size
= sizeof(struct smb2_read_rsp
) - 1,
1626 .lock_cmd
= SMB2_LOCK
,
1628 .cap_nt_find
= SMB2_NT_FIND
,
1629 .cap_large_files
= SMB2_LARGE_FILES
,
1630 .signing_enabled
= SMB2_NEGOTIATE_SIGNING_ENABLED
| SMB2_NEGOTIATE_SIGNING_REQUIRED
,
1631 .signing_required
= SMB2_NEGOTIATE_SIGNING_REQUIRED
,
1632 .create_lease_size
= sizeof(struct create_lease_v2
),
1635 struct smb_version_values smb302_values
= {
1636 .version_string
= SMB302_VERSION_STRING
,
1637 .protocol_id
= SMB302_PROT_ID
,
1638 .req_capabilities
= SMB2_GLOBAL_CAP_DFS
| SMB2_GLOBAL_CAP_LEASING
| SMB2_GLOBAL_CAP_LARGE_MTU
,
1639 .large_lock_type
= 0,
1640 .exclusive_lock_type
= SMB2_LOCKFLAG_EXCLUSIVE_LOCK
,
1641 .shared_lock_type
= SMB2_LOCKFLAG_SHARED_LOCK
,
1642 .unlock_lock_type
= SMB2_LOCKFLAG_UNLOCK
,
1643 .header_size
= sizeof(struct smb2_hdr
),
1644 .max_header_size
= MAX_SMB2_HDR_SIZE
,
1645 .read_rsp_size
= sizeof(struct smb2_read_rsp
) - 1,
1646 .lock_cmd
= SMB2_LOCK
,
1648 .cap_nt_find
= SMB2_NT_FIND
,
1649 .cap_large_files
= SMB2_LARGE_FILES
,
1650 .signing_enabled
= SMB2_NEGOTIATE_SIGNING_ENABLED
| SMB2_NEGOTIATE_SIGNING_REQUIRED
,
1651 .signing_required
= SMB2_NEGOTIATE_SIGNING_REQUIRED
,
1652 .create_lease_size
= sizeof(struct create_lease_v2
),