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>
24 #include "smb2proto.h"
25 #include "cifsproto.h"
26 #include "cifs_debug.h"
27 #include "cifs_unicode.h"
28 #include "smb2status.h"
32 change_conf(struct TCP_Server_Info
*server
)
34 server
->credits
+= server
->echo_credits
+ server
->oplock_credits
;
35 server
->oplock_credits
= server
->echo_credits
= 0;
36 switch (server
->credits
) {
40 server
->echoes
= false;
41 server
->oplocks
= false;
42 cifs_dbg(VFS
, "disabling echoes and oplocks\n");
45 server
->echoes
= true;
46 server
->oplocks
= false;
47 server
->echo_credits
= 1;
48 cifs_dbg(FYI
, "disabling oplocks\n");
51 server
->echoes
= true;
52 server
->oplocks
= true;
53 server
->echo_credits
= 1;
54 server
->oplock_credits
= 1;
56 server
->credits
-= server
->echo_credits
+ server
->oplock_credits
;
61 smb2_add_credits(struct TCP_Server_Info
*server
, const unsigned int add
,
65 spin_lock(&server
->req_lock
);
66 val
= server
->ops
->get_credits_field(server
, optype
);
69 if (server
->in_flight
== 0 && (optype
& CIFS_OP_MASK
) != CIFS_NEG_OP
)
70 rc
= change_conf(server
);
72 * Sometimes server returns 0 credits on oplock break ack - we need to
73 * rebalance credits in this case.
75 else if (server
->in_flight
> 0 && server
->oplock_credits
== 0 &&
77 if (server
->credits
> 1) {
79 server
->oplock_credits
++;
82 spin_unlock(&server
->req_lock
);
83 wake_up(&server
->request_q
);
85 cifs_reconnect(server
);
89 smb2_set_credits(struct TCP_Server_Info
*server
, const int val
)
91 spin_lock(&server
->req_lock
);
92 server
->credits
= val
;
93 spin_unlock(&server
->req_lock
);
97 smb2_get_credits_field(struct TCP_Server_Info
*server
, const int optype
)
101 return &server
->echo_credits
;
103 return &server
->oplock_credits
;
105 return &server
->credits
;
110 smb2_get_credits(struct mid_q_entry
*mid
)
112 return le16_to_cpu(((struct smb2_hdr
*)mid
->resp_buf
)->CreditRequest
);
116 smb2_get_next_mid(struct TCP_Server_Info
*server
)
119 /* for SMB2 we need the current value */
120 spin_lock(&GlobalMid_Lock
);
121 mid
= server
->CurrentMid
++;
122 spin_unlock(&GlobalMid_Lock
);
126 static struct mid_q_entry
*
127 smb2_find_mid(struct TCP_Server_Info
*server
, char *buf
)
129 struct mid_q_entry
*mid
;
130 struct smb2_hdr
*hdr
= (struct smb2_hdr
*)buf
;
132 spin_lock(&GlobalMid_Lock
);
133 list_for_each_entry(mid
, &server
->pending_mid_q
, qhead
) {
134 if ((mid
->mid
== hdr
->MessageId
) &&
135 (mid
->mid_state
== MID_REQUEST_SUBMITTED
) &&
136 (mid
->command
== hdr
->Command
)) {
137 spin_unlock(&GlobalMid_Lock
);
141 spin_unlock(&GlobalMid_Lock
);
146 smb2_dump_detail(void *buf
)
148 #ifdef CONFIG_CIFS_DEBUG2
149 struct smb2_hdr
*smb
= (struct smb2_hdr
*)buf
;
151 cifs_dbg(VFS
, "Cmd: %d Err: 0x%x Flags: 0x%x Mid: %llu Pid: %d\n",
152 smb
->Command
, smb
->Status
, smb
->Flags
, smb
->MessageId
,
154 cifs_dbg(VFS
, "smb buf %p len %u\n", smb
, smb2_calc_size(smb
));
159 smb2_need_neg(struct TCP_Server_Info
*server
)
161 return server
->max_read
== 0;
165 smb2_negotiate(const unsigned int xid
, struct cifs_ses
*ses
)
168 ses
->server
->CurrentMid
= 0;
169 rc
= SMB2_negotiate(xid
, ses
);
170 /* BB we probably don't need to retry with modern servers */
177 smb2_negotiate_wsize(struct cifs_tcon
*tcon
, struct smb_vol
*volume_info
)
179 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
182 /* start with specified wsize, or default */
183 wsize
= volume_info
->wsize
? volume_info
->wsize
: CIFS_DEFAULT_IOSIZE
;
184 wsize
= min_t(unsigned int, wsize
, server
->max_write
);
186 * limit write size to 2 ** 16, because we don't support multicredit
189 wsize
= min_t(unsigned int, wsize
, 2 << 15);
195 smb2_negotiate_rsize(struct cifs_tcon
*tcon
, struct smb_vol
*volume_info
)
197 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
200 /* start with specified rsize, or default */
201 rsize
= volume_info
->rsize
? volume_info
->rsize
: CIFS_DEFAULT_IOSIZE
;
202 rsize
= min_t(unsigned int, rsize
, server
->max_read
);
204 * limit write size to 2 ** 16, because we don't support multicredit
207 rsize
= min_t(unsigned int, rsize
, 2 << 15);
213 smb2_qfs_tcon(const unsigned int xid
, struct cifs_tcon
*tcon
)
216 __le16 srch_path
= 0; /* Null - open root of share */
217 u8 oplock
= SMB2_OPLOCK_LEVEL_NONE
;
218 struct cifs_open_parms oparms
;
222 oparms
.desired_access
= FILE_READ_ATTRIBUTES
;
223 oparms
.disposition
= FILE_OPEN
;
224 oparms
.create_options
= 0;
226 oparms
.reconnect
= false;
228 rc
= SMB2_open(xid
, &oparms
, &srch_path
, &oplock
, NULL
, NULL
);
232 SMB2_QFS_attr(xid
, tcon
, fid
.persistent_fid
, fid
.volatile_fid
,
233 FS_ATTRIBUTE_INFORMATION
);
234 SMB2_QFS_attr(xid
, tcon
, fid
.persistent_fid
, fid
.volatile_fid
,
235 FS_DEVICE_INFORMATION
);
236 SMB2_close(xid
, tcon
, fid
.persistent_fid
, fid
.volatile_fid
);
241 smb2_is_path_accessible(const unsigned int xid
, struct cifs_tcon
*tcon
,
242 struct cifs_sb_info
*cifs_sb
, const char *full_path
)
246 __u8 oplock
= SMB2_OPLOCK_LEVEL_NONE
;
247 struct cifs_open_parms oparms
;
250 utf16_path
= cifs_convert_path_to_utf16(full_path
, cifs_sb
);
255 oparms
.desired_access
= FILE_READ_ATTRIBUTES
;
256 oparms
.disposition
= FILE_OPEN
;
257 oparms
.create_options
= 0;
259 oparms
.reconnect
= false;
261 rc
= SMB2_open(xid
, &oparms
, utf16_path
, &oplock
, NULL
, NULL
);
267 rc
= SMB2_close(xid
, tcon
, fid
.persistent_fid
, fid
.volatile_fid
);
273 smb2_get_srv_inum(const unsigned int xid
, struct cifs_tcon
*tcon
,
274 struct cifs_sb_info
*cifs_sb
, const char *full_path
,
275 u64
*uniqueid
, FILE_ALL_INFO
*data
)
277 *uniqueid
= le64_to_cpu(data
->IndexNumber
);
282 smb2_query_file_info(const unsigned int xid
, struct cifs_tcon
*tcon
,
283 struct cifs_fid
*fid
, FILE_ALL_INFO
*data
)
286 struct smb2_file_all_info
*smb2_data
;
288 smb2_data
= kzalloc(sizeof(struct smb2_file_all_info
) + MAX_NAME
* 2,
290 if (smb2_data
== NULL
)
293 rc
= SMB2_query_info(xid
, tcon
, fid
->persistent_fid
, fid
->volatile_fid
,
296 move_smb2_info_to_cifs(data
, smb2_data
);
302 smb2_can_echo(struct TCP_Server_Info
*server
)
304 return server
->echoes
;
308 smb2_clear_stats(struct cifs_tcon
*tcon
)
310 #ifdef CONFIG_CIFS_STATS
312 for (i
= 0; i
< NUMBER_OF_SMB2_COMMANDS
; i
++) {
313 atomic_set(&tcon
->stats
.smb2_stats
.smb2_com_sent
[i
], 0);
314 atomic_set(&tcon
->stats
.smb2_stats
.smb2_com_failed
[i
], 0);
320 smb2_dump_share_caps(struct seq_file
*m
, struct cifs_tcon
*tcon
)
322 seq_puts(m
, "\n\tShare Capabilities:");
323 if (tcon
->capabilities
& SMB2_SHARE_CAP_DFS
)
324 seq_puts(m
, " DFS,");
325 if (tcon
->capabilities
& SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY
)
326 seq_puts(m
, " CONTINUOUS AVAILABILITY,");
327 if (tcon
->capabilities
& SMB2_SHARE_CAP_SCALEOUT
)
328 seq_puts(m
, " SCALEOUT,");
329 if (tcon
->capabilities
& SMB2_SHARE_CAP_CLUSTER
)
330 seq_puts(m
, " CLUSTER,");
331 if (tcon
->capabilities
& SMB2_SHARE_CAP_ASYMMETRIC
)
332 seq_puts(m
, " ASYMMETRIC,");
333 if (tcon
->capabilities
== 0)
334 seq_puts(m
, " None");
335 seq_printf(m
, "\tShare Flags: 0x%x", tcon
->share_flags
);
339 smb2_print_stats(struct seq_file
*m
, struct cifs_tcon
*tcon
)
341 #ifdef CONFIG_CIFS_STATS
342 atomic_t
*sent
= tcon
->stats
.smb2_stats
.smb2_com_sent
;
343 atomic_t
*failed
= tcon
->stats
.smb2_stats
.smb2_com_failed
;
344 seq_printf(m
, "\nNegotiates: %d sent %d failed",
345 atomic_read(&sent
[SMB2_NEGOTIATE_HE
]),
346 atomic_read(&failed
[SMB2_NEGOTIATE_HE
]));
347 seq_printf(m
, "\nSessionSetups: %d sent %d failed",
348 atomic_read(&sent
[SMB2_SESSION_SETUP_HE
]),
349 atomic_read(&failed
[SMB2_SESSION_SETUP_HE
]));
350 seq_printf(m
, "\nLogoffs: %d sent %d failed",
351 atomic_read(&sent
[SMB2_LOGOFF_HE
]),
352 atomic_read(&failed
[SMB2_LOGOFF_HE
]));
353 seq_printf(m
, "\nTreeConnects: %d sent %d failed",
354 atomic_read(&sent
[SMB2_TREE_CONNECT_HE
]),
355 atomic_read(&failed
[SMB2_TREE_CONNECT_HE
]));
356 seq_printf(m
, "\nTreeDisconnects: %d sent %d failed",
357 atomic_read(&sent
[SMB2_TREE_DISCONNECT_HE
]),
358 atomic_read(&failed
[SMB2_TREE_DISCONNECT_HE
]));
359 seq_printf(m
, "\nCreates: %d sent %d failed",
360 atomic_read(&sent
[SMB2_CREATE_HE
]),
361 atomic_read(&failed
[SMB2_CREATE_HE
]));
362 seq_printf(m
, "\nCloses: %d sent %d failed",
363 atomic_read(&sent
[SMB2_CLOSE_HE
]),
364 atomic_read(&failed
[SMB2_CLOSE_HE
]));
365 seq_printf(m
, "\nFlushes: %d sent %d failed",
366 atomic_read(&sent
[SMB2_FLUSH_HE
]),
367 atomic_read(&failed
[SMB2_FLUSH_HE
]));
368 seq_printf(m
, "\nReads: %d sent %d failed",
369 atomic_read(&sent
[SMB2_READ_HE
]),
370 atomic_read(&failed
[SMB2_READ_HE
]));
371 seq_printf(m
, "\nWrites: %d sent %d failed",
372 atomic_read(&sent
[SMB2_WRITE_HE
]),
373 atomic_read(&failed
[SMB2_WRITE_HE
]));
374 seq_printf(m
, "\nLocks: %d sent %d failed",
375 atomic_read(&sent
[SMB2_LOCK_HE
]),
376 atomic_read(&failed
[SMB2_LOCK_HE
]));
377 seq_printf(m
, "\nIOCTLs: %d sent %d failed",
378 atomic_read(&sent
[SMB2_IOCTL_HE
]),
379 atomic_read(&failed
[SMB2_IOCTL_HE
]));
380 seq_printf(m
, "\nCancels: %d sent %d failed",
381 atomic_read(&sent
[SMB2_CANCEL_HE
]),
382 atomic_read(&failed
[SMB2_CANCEL_HE
]));
383 seq_printf(m
, "\nEchos: %d sent %d failed",
384 atomic_read(&sent
[SMB2_ECHO_HE
]),
385 atomic_read(&failed
[SMB2_ECHO_HE
]));
386 seq_printf(m
, "\nQueryDirectories: %d sent %d failed",
387 atomic_read(&sent
[SMB2_QUERY_DIRECTORY_HE
]),
388 atomic_read(&failed
[SMB2_QUERY_DIRECTORY_HE
]));
389 seq_printf(m
, "\nChangeNotifies: %d sent %d failed",
390 atomic_read(&sent
[SMB2_CHANGE_NOTIFY_HE
]),
391 atomic_read(&failed
[SMB2_CHANGE_NOTIFY_HE
]));
392 seq_printf(m
, "\nQueryInfos: %d sent %d failed",
393 atomic_read(&sent
[SMB2_QUERY_INFO_HE
]),
394 atomic_read(&failed
[SMB2_QUERY_INFO_HE
]));
395 seq_printf(m
, "\nSetInfos: %d sent %d failed",
396 atomic_read(&sent
[SMB2_SET_INFO_HE
]),
397 atomic_read(&failed
[SMB2_SET_INFO_HE
]));
398 seq_printf(m
, "\nOplockBreaks: %d sent %d failed",
399 atomic_read(&sent
[SMB2_OPLOCK_BREAK_HE
]),
400 atomic_read(&failed
[SMB2_OPLOCK_BREAK_HE
]));
405 smb2_set_fid(struct cifsFileInfo
*cfile
, struct cifs_fid
*fid
, __u32 oplock
)
407 struct cifsInodeInfo
*cinode
= CIFS_I(cfile
->dentry
->d_inode
);
408 struct TCP_Server_Info
*server
= tlink_tcon(cfile
->tlink
)->ses
->server
;
410 cfile
->fid
.persistent_fid
= fid
->persistent_fid
;
411 cfile
->fid
.volatile_fid
= fid
->volatile_fid
;
412 server
->ops
->set_oplock_level(cinode
, oplock
, fid
->epoch
,
414 cinode
->can_cache_brlcks
= CIFS_CACHE_WRITE(cinode
);
418 smb2_close_file(const unsigned int xid
, struct cifs_tcon
*tcon
,
419 struct cifs_fid
*fid
)
421 SMB2_close(xid
, tcon
, fid
->persistent_fid
, fid
->volatile_fid
);
425 smb2_flush_file(const unsigned int xid
, struct cifs_tcon
*tcon
,
426 struct cifs_fid
*fid
)
428 return SMB2_flush(xid
, tcon
, fid
->persistent_fid
, fid
->volatile_fid
);
432 smb2_read_data_offset(char *buf
)
434 struct smb2_read_rsp
*rsp
= (struct smb2_read_rsp
*)buf
;
435 return rsp
->DataOffset
;
439 smb2_read_data_length(char *buf
)
441 struct smb2_read_rsp
*rsp
= (struct smb2_read_rsp
*)buf
;
442 return le32_to_cpu(rsp
->DataLength
);
447 smb2_sync_read(const unsigned int xid
, struct cifsFileInfo
*cfile
,
448 struct cifs_io_parms
*parms
, unsigned int *bytes_read
,
449 char **buf
, int *buf_type
)
451 parms
->persistent_fid
= cfile
->fid
.persistent_fid
;
452 parms
->volatile_fid
= cfile
->fid
.volatile_fid
;
453 return SMB2_read(xid
, parms
, bytes_read
, buf
, buf_type
);
457 smb2_sync_write(const unsigned int xid
, struct cifsFileInfo
*cfile
,
458 struct cifs_io_parms
*parms
, unsigned int *written
,
459 struct kvec
*iov
, unsigned long nr_segs
)
462 parms
->persistent_fid
= cfile
->fid
.persistent_fid
;
463 parms
->volatile_fid
= cfile
->fid
.volatile_fid
;
464 return SMB2_write(xid
, parms
, written
, iov
, nr_segs
);
468 smb2_set_file_size(const unsigned int xid
, struct cifs_tcon
*tcon
,
469 struct cifsFileInfo
*cfile
, __u64 size
, bool set_alloc
)
471 __le64 eof
= cpu_to_le64(size
);
472 return SMB2_set_eof(xid
, tcon
, cfile
->fid
.persistent_fid
,
473 cfile
->fid
.volatile_fid
, cfile
->pid
, &eof
);
477 smb2_set_compression(const unsigned int xid
, struct cifs_tcon
*tcon
,
478 struct cifsFileInfo
*cfile
)
480 return SMB2_set_compression(xid
, tcon
, cfile
->fid
.persistent_fid
,
481 cfile
->fid
.volatile_fid
);
485 smb2_query_dir_first(const unsigned int xid
, struct cifs_tcon
*tcon
,
486 const char *path
, struct cifs_sb_info
*cifs_sb
,
487 struct cifs_fid
*fid
, __u16 search_flags
,
488 struct cifs_search_info
*srch_inf
)
492 __u8 oplock
= SMB2_OPLOCK_LEVEL_NONE
;
493 struct cifs_open_parms oparms
;
495 utf16_path
= cifs_convert_path_to_utf16(path
, cifs_sb
);
500 oparms
.desired_access
= FILE_READ_ATTRIBUTES
| FILE_READ_DATA
;
501 oparms
.disposition
= FILE_OPEN
;
502 oparms
.create_options
= 0;
504 oparms
.reconnect
= false;
506 rc
= SMB2_open(xid
, &oparms
, utf16_path
, &oplock
, NULL
, NULL
);
509 cifs_dbg(VFS
, "open dir failed\n");
513 srch_inf
->entries_in_buffer
= 0;
514 srch_inf
->index_of_last_entry
= 0;
516 rc
= SMB2_query_directory(xid
, tcon
, fid
->persistent_fid
,
517 fid
->volatile_fid
, 0, srch_inf
);
519 cifs_dbg(VFS
, "query directory failed\n");
520 SMB2_close(xid
, tcon
, fid
->persistent_fid
, fid
->volatile_fid
);
526 smb2_query_dir_next(const unsigned int xid
, struct cifs_tcon
*tcon
,
527 struct cifs_fid
*fid
, __u16 search_flags
,
528 struct cifs_search_info
*srch_inf
)
530 return SMB2_query_directory(xid
, tcon
, fid
->persistent_fid
,
531 fid
->volatile_fid
, 0, srch_inf
);
535 smb2_close_dir(const unsigned int xid
, struct cifs_tcon
*tcon
,
536 struct cifs_fid
*fid
)
538 return SMB2_close(xid
, tcon
, fid
->persistent_fid
, fid
->volatile_fid
);
542 * If we negotiate SMB2 protocol and get STATUS_PENDING - update
543 * the number of credits and return true. Otherwise - return false.
546 smb2_is_status_pending(char *buf
, struct TCP_Server_Info
*server
, int length
)
548 struct smb2_hdr
*hdr
= (struct smb2_hdr
*)buf
;
550 if (hdr
->Status
!= STATUS_PENDING
)
554 spin_lock(&server
->req_lock
);
555 server
->credits
+= le16_to_cpu(hdr
->CreditRequest
);
556 spin_unlock(&server
->req_lock
);
557 wake_up(&server
->request_q
);
564 smb2_oplock_response(struct cifs_tcon
*tcon
, struct cifs_fid
*fid
,
565 struct cifsInodeInfo
*cinode
)
567 if (tcon
->ses
->server
->capabilities
& SMB2_GLOBAL_CAP_LEASING
)
568 return SMB2_lease_break(0, tcon
, cinode
->lease_key
,
569 smb2_get_lease_state(cinode
));
571 return SMB2_oplock_break(0, tcon
, fid
->persistent_fid
,
573 CIFS_CACHE_READ(cinode
) ? 1 : 0);
577 smb2_queryfs(const unsigned int xid
, struct cifs_tcon
*tcon
,
581 __le16 srch_path
= 0; /* Null - open root of share */
582 u8 oplock
= SMB2_OPLOCK_LEVEL_NONE
;
583 struct cifs_open_parms oparms
;
587 oparms
.desired_access
= FILE_READ_ATTRIBUTES
;
588 oparms
.disposition
= FILE_OPEN
;
589 oparms
.create_options
= 0;
591 oparms
.reconnect
= false;
593 rc
= SMB2_open(xid
, &oparms
, &srch_path
, &oplock
, NULL
, NULL
);
596 buf
->f_type
= SMB2_MAGIC_NUMBER
;
597 rc
= SMB2_QFS_info(xid
, tcon
, fid
.persistent_fid
, fid
.volatile_fid
,
599 SMB2_close(xid
, tcon
, fid
.persistent_fid
, fid
.volatile_fid
);
604 smb2_compare_fids(struct cifsFileInfo
*ob1
, struct cifsFileInfo
*ob2
)
606 return ob1
->fid
.persistent_fid
== ob2
->fid
.persistent_fid
&&
607 ob1
->fid
.volatile_fid
== ob2
->fid
.volatile_fid
;
611 smb2_mand_lock(const unsigned int xid
, struct cifsFileInfo
*cfile
, __u64 offset
,
612 __u64 length
, __u32 type
, int lock
, int unlock
, bool wait
)
615 type
= SMB2_LOCKFLAG_UNLOCK
;
616 return SMB2_lock(xid
, tlink_tcon(cfile
->tlink
),
617 cfile
->fid
.persistent_fid
, cfile
->fid
.volatile_fid
,
618 current
->tgid
, length
, offset
, type
, wait
);
622 smb2_get_lease_key(struct inode
*inode
, struct cifs_fid
*fid
)
624 memcpy(fid
->lease_key
, CIFS_I(inode
)->lease_key
, SMB2_LEASE_KEY_SIZE
);
628 smb2_set_lease_key(struct inode
*inode
, struct cifs_fid
*fid
)
630 memcpy(CIFS_I(inode
)->lease_key
, fid
->lease_key
, SMB2_LEASE_KEY_SIZE
);
634 smb2_new_lease_key(struct cifs_fid
*fid
)
636 get_random_bytes(fid
->lease_key
, SMB2_LEASE_KEY_SIZE
);
640 smb2_query_symlink(const unsigned int xid
, struct cifs_tcon
*tcon
,
641 const char *full_path
, char **target_path
,
642 struct cifs_sb_info
*cifs_sb
)
646 __u8 oplock
= SMB2_OPLOCK_LEVEL_NONE
;
647 struct cifs_open_parms oparms
;
649 struct smb2_err_rsp
*err_buf
= NULL
;
650 struct smb2_symlink_err_rsp
*symlink
;
651 unsigned int sub_len
, sub_offset
;
653 cifs_dbg(FYI
, "%s: path: %s\n", __func__
, full_path
);
655 utf16_path
= cifs_convert_path_to_utf16(full_path
, cifs_sb
);
660 oparms
.desired_access
= FILE_READ_ATTRIBUTES
;
661 oparms
.disposition
= FILE_OPEN
;
662 oparms
.create_options
= 0;
664 oparms
.reconnect
= false;
666 rc
= SMB2_open(xid
, &oparms
, utf16_path
, &oplock
, NULL
, &err_buf
);
668 if (!rc
|| !err_buf
) {
672 /* open must fail on symlink - reset rc */
674 symlink
= (struct smb2_symlink_err_rsp
*)err_buf
->ErrorData
;
675 sub_len
= le16_to_cpu(symlink
->SubstituteNameLength
);
676 sub_offset
= le16_to_cpu(symlink
->SubstituteNameOffset
);
677 *target_path
= cifs_strndup_from_utf16(
678 (char *)symlink
->PathBuffer
+ sub_offset
,
679 sub_len
, true, cifs_sb
->local_nls
);
680 if (!(*target_path
)) {
684 convert_delimiter(*target_path
, '/');
685 cifs_dbg(FYI
, "%s: target path: %s\n", __func__
, *target_path
);
691 smb2_set_oplock_level(struct cifsInodeInfo
*cinode
, __u32 oplock
,
692 unsigned int epoch
, bool *purge_cache
)
695 if (oplock
== SMB2_OPLOCK_LEVEL_NOCHANGE
)
697 if (oplock
== SMB2_OPLOCK_LEVEL_BATCH
) {
698 cinode
->oplock
= CIFS_CACHE_RHW_FLG
;
699 cifs_dbg(FYI
, "Batch Oplock granted on inode %p\n",
701 } else if (oplock
== SMB2_OPLOCK_LEVEL_EXCLUSIVE
) {
702 cinode
->oplock
= CIFS_CACHE_RW_FLG
;
703 cifs_dbg(FYI
, "Exclusive Oplock granted on inode %p\n",
705 } else if (oplock
== SMB2_OPLOCK_LEVEL_II
) {
706 cinode
->oplock
= CIFS_CACHE_READ_FLG
;
707 cifs_dbg(FYI
, "Level II Oplock granted on inode %p\n",
714 smb21_set_oplock_level(struct cifsInodeInfo
*cinode
, __u32 oplock
,
715 unsigned int epoch
, bool *purge_cache
)
717 char message
[5] = {0};
720 if (oplock
== SMB2_OPLOCK_LEVEL_NOCHANGE
)
724 if (oplock
& SMB2_LEASE_READ_CACHING_HE
) {
725 cinode
->oplock
|= CIFS_CACHE_READ_FLG
;
726 strcat(message
, "R");
728 if (oplock
& SMB2_LEASE_HANDLE_CACHING_HE
) {
729 cinode
->oplock
|= CIFS_CACHE_HANDLE_FLG
;
730 strcat(message
, "H");
732 if (oplock
& SMB2_LEASE_WRITE_CACHING_HE
) {
733 cinode
->oplock
|= CIFS_CACHE_WRITE_FLG
;
734 strcat(message
, "W");
737 strcat(message
, "None");
738 cifs_dbg(FYI
, "%s Lease granted on inode %p\n", message
,
743 smb3_set_oplock_level(struct cifsInodeInfo
*cinode
, __u32 oplock
,
744 unsigned int epoch
, bool *purge_cache
)
746 unsigned int old_oplock
= cinode
->oplock
;
748 smb21_set_oplock_level(cinode
, oplock
, epoch
, purge_cache
);
751 *purge_cache
= false;
752 if (old_oplock
== CIFS_CACHE_READ_FLG
) {
753 if (cinode
->oplock
== CIFS_CACHE_READ_FLG
&&
754 (epoch
- cinode
->epoch
> 0))
756 else if (cinode
->oplock
== CIFS_CACHE_RH_FLG
&&
757 (epoch
- cinode
->epoch
> 1))
759 else if (cinode
->oplock
== CIFS_CACHE_RHW_FLG
&&
760 (epoch
- cinode
->epoch
> 1))
762 else if (cinode
->oplock
== 0 &&
763 (epoch
- cinode
->epoch
> 0))
765 } else if (old_oplock
== CIFS_CACHE_RH_FLG
) {
766 if (cinode
->oplock
== CIFS_CACHE_RH_FLG
&&
767 (epoch
- cinode
->epoch
> 0))
769 else if (cinode
->oplock
== CIFS_CACHE_RHW_FLG
&&
770 (epoch
- cinode
->epoch
> 1))
773 cinode
->epoch
= epoch
;
778 smb2_is_read_op(__u32 oplock
)
780 return oplock
== SMB2_OPLOCK_LEVEL_II
;
784 smb21_is_read_op(__u32 oplock
)
786 return (oplock
& SMB2_LEASE_READ_CACHING_HE
) &&
787 !(oplock
& SMB2_LEASE_WRITE_CACHING_HE
);
791 map_oplock_to_lease(u8 oplock
)
793 if (oplock
== SMB2_OPLOCK_LEVEL_EXCLUSIVE
)
794 return SMB2_LEASE_WRITE_CACHING
| SMB2_LEASE_READ_CACHING
;
795 else if (oplock
== SMB2_OPLOCK_LEVEL_II
)
796 return SMB2_LEASE_READ_CACHING
;
797 else if (oplock
== SMB2_OPLOCK_LEVEL_BATCH
)
798 return SMB2_LEASE_HANDLE_CACHING
| SMB2_LEASE_READ_CACHING
|
799 SMB2_LEASE_WRITE_CACHING
;
804 smb2_create_lease_buf(u8
*lease_key
, u8 oplock
)
806 struct create_lease
*buf
;
808 buf
= kzalloc(sizeof(struct create_lease
), GFP_KERNEL
);
812 buf
->lcontext
.LeaseKeyLow
= cpu_to_le64(*((u64
*)lease_key
));
813 buf
->lcontext
.LeaseKeyHigh
= cpu_to_le64(*((u64
*)(lease_key
+ 8)));
814 buf
->lcontext
.LeaseState
= map_oplock_to_lease(oplock
);
816 buf
->ccontext
.DataOffset
= cpu_to_le16(offsetof
817 (struct create_lease
, lcontext
));
818 buf
->ccontext
.DataLength
= cpu_to_le32(sizeof(struct lease_context
));
819 buf
->ccontext
.NameOffset
= cpu_to_le16(offsetof
820 (struct create_lease
, Name
));
821 buf
->ccontext
.NameLength
= cpu_to_le16(4);
830 smb3_create_lease_buf(u8
*lease_key
, u8 oplock
)
832 struct create_lease_v2
*buf
;
834 buf
= kzalloc(sizeof(struct create_lease_v2
), GFP_KERNEL
);
838 buf
->lcontext
.LeaseKeyLow
= cpu_to_le64(*((u64
*)lease_key
));
839 buf
->lcontext
.LeaseKeyHigh
= cpu_to_le64(*((u64
*)(lease_key
+ 8)));
840 buf
->lcontext
.LeaseState
= map_oplock_to_lease(oplock
);
842 buf
->ccontext
.DataOffset
= cpu_to_le16(offsetof
843 (struct create_lease_v2
, lcontext
));
844 buf
->ccontext
.DataLength
= cpu_to_le32(sizeof(struct lease_context_v2
));
845 buf
->ccontext
.NameOffset
= cpu_to_le16(offsetof
846 (struct create_lease_v2
, Name
));
847 buf
->ccontext
.NameLength
= cpu_to_le16(4);
856 smb2_parse_lease_buf(void *buf
, unsigned int *epoch
)
858 struct create_lease
*lc
= (struct create_lease
*)buf
;
860 *epoch
= 0; /* not used */
861 if (lc
->lcontext
.LeaseFlags
& SMB2_LEASE_FLAG_BREAK_IN_PROGRESS
)
862 return SMB2_OPLOCK_LEVEL_NOCHANGE
;
863 return le32_to_cpu(lc
->lcontext
.LeaseState
);
867 smb3_parse_lease_buf(void *buf
, unsigned int *epoch
)
869 struct create_lease_v2
*lc
= (struct create_lease_v2
*)buf
;
871 *epoch
= le16_to_cpu(lc
->lcontext
.Epoch
);
872 if (lc
->lcontext
.LeaseFlags
& SMB2_LEASE_FLAG_BREAK_IN_PROGRESS
)
873 return SMB2_OPLOCK_LEVEL_NOCHANGE
;
874 return le32_to_cpu(lc
->lcontext
.LeaseState
);
877 struct smb_version_operations smb20_operations
= {
878 .compare_fids
= smb2_compare_fids
,
879 .setup_request
= smb2_setup_request
,
880 .setup_async_request
= smb2_setup_async_request
,
881 .check_receive
= smb2_check_receive
,
882 .add_credits
= smb2_add_credits
,
883 .set_credits
= smb2_set_credits
,
884 .get_credits_field
= smb2_get_credits_field
,
885 .get_credits
= smb2_get_credits
,
886 .get_next_mid
= smb2_get_next_mid
,
887 .read_data_offset
= smb2_read_data_offset
,
888 .read_data_length
= smb2_read_data_length
,
889 .map_error
= map_smb2_to_linux_error
,
890 .find_mid
= smb2_find_mid
,
891 .check_message
= smb2_check_message
,
892 .dump_detail
= smb2_dump_detail
,
893 .clear_stats
= smb2_clear_stats
,
894 .print_stats
= smb2_print_stats
,
895 .is_oplock_break
= smb2_is_valid_oplock_break
,
896 .need_neg
= smb2_need_neg
,
897 .negotiate
= smb2_negotiate
,
898 .negotiate_wsize
= smb2_negotiate_wsize
,
899 .negotiate_rsize
= smb2_negotiate_rsize
,
900 .sess_setup
= SMB2_sess_setup
,
901 .logoff
= SMB2_logoff
,
902 .tree_connect
= SMB2_tcon
,
903 .tree_disconnect
= SMB2_tdis
,
904 .qfs_tcon
= smb2_qfs_tcon
,
905 .is_path_accessible
= smb2_is_path_accessible
,
906 .can_echo
= smb2_can_echo
,
908 .query_path_info
= smb2_query_path_info
,
909 .get_srv_inum
= smb2_get_srv_inum
,
910 .query_file_info
= smb2_query_file_info
,
911 .set_path_size
= smb2_set_path_size
,
912 .set_file_size
= smb2_set_file_size
,
913 .set_file_info
= smb2_set_file_info
,
914 .set_compression
= smb2_set_compression
,
916 .mkdir_setinfo
= smb2_mkdir_setinfo
,
918 .unlink
= smb2_unlink
,
919 .rename
= smb2_rename_path
,
920 .create_hardlink
= smb2_create_hardlink
,
921 .query_symlink
= smb2_query_symlink
,
922 .open
= smb2_open_file
,
923 .set_fid
= smb2_set_fid
,
924 .close
= smb2_close_file
,
925 .flush
= smb2_flush_file
,
926 .async_readv
= smb2_async_readv
,
927 .async_writev
= smb2_async_writev
,
928 .sync_read
= smb2_sync_read
,
929 .sync_write
= smb2_sync_write
,
930 .query_dir_first
= smb2_query_dir_first
,
931 .query_dir_next
= smb2_query_dir_next
,
932 .close_dir
= smb2_close_dir
,
933 .calc_smb_size
= smb2_calc_size
,
934 .is_status_pending
= smb2_is_status_pending
,
935 .oplock_response
= smb2_oplock_response
,
936 .queryfs
= smb2_queryfs
,
937 .mand_lock
= smb2_mand_lock
,
938 .mand_unlock_range
= smb2_unlock_range
,
939 .push_mand_locks
= smb2_push_mandatory_locks
,
940 .get_lease_key
= smb2_get_lease_key
,
941 .set_lease_key
= smb2_set_lease_key
,
942 .new_lease_key
= smb2_new_lease_key
,
943 .calc_signature
= smb2_calc_signature
,
944 .is_read_op
= smb2_is_read_op
,
945 .set_oplock_level
= smb2_set_oplock_level
,
946 .create_lease_buf
= smb2_create_lease_buf
,
947 .parse_lease_buf
= smb2_parse_lease_buf
,
950 struct smb_version_operations smb21_operations
= {
951 .compare_fids
= smb2_compare_fids
,
952 .setup_request
= smb2_setup_request
,
953 .setup_async_request
= smb2_setup_async_request
,
954 .check_receive
= smb2_check_receive
,
955 .add_credits
= smb2_add_credits
,
956 .set_credits
= smb2_set_credits
,
957 .get_credits_field
= smb2_get_credits_field
,
958 .get_credits
= smb2_get_credits
,
959 .get_next_mid
= smb2_get_next_mid
,
960 .read_data_offset
= smb2_read_data_offset
,
961 .read_data_length
= smb2_read_data_length
,
962 .map_error
= map_smb2_to_linux_error
,
963 .find_mid
= smb2_find_mid
,
964 .check_message
= smb2_check_message
,
965 .dump_detail
= smb2_dump_detail
,
966 .clear_stats
= smb2_clear_stats
,
967 .print_stats
= smb2_print_stats
,
968 .is_oplock_break
= smb2_is_valid_oplock_break
,
969 .need_neg
= smb2_need_neg
,
970 .negotiate
= smb2_negotiate
,
971 .negotiate_wsize
= smb2_negotiate_wsize
,
972 .negotiate_rsize
= smb2_negotiate_rsize
,
973 .sess_setup
= SMB2_sess_setup
,
974 .logoff
= SMB2_logoff
,
975 .tree_connect
= SMB2_tcon
,
976 .tree_disconnect
= SMB2_tdis
,
977 .qfs_tcon
= smb2_qfs_tcon
,
978 .is_path_accessible
= smb2_is_path_accessible
,
979 .can_echo
= smb2_can_echo
,
981 .query_path_info
= smb2_query_path_info
,
982 .get_srv_inum
= smb2_get_srv_inum
,
983 .query_file_info
= smb2_query_file_info
,
984 .set_path_size
= smb2_set_path_size
,
985 .set_file_size
= smb2_set_file_size
,
986 .set_file_info
= smb2_set_file_info
,
987 .set_compression
= smb2_set_compression
,
989 .mkdir_setinfo
= smb2_mkdir_setinfo
,
991 .unlink
= smb2_unlink
,
992 .rename
= smb2_rename_path
,
993 .create_hardlink
= smb2_create_hardlink
,
994 .query_symlink
= smb2_query_symlink
,
995 .open
= smb2_open_file
,
996 .set_fid
= smb2_set_fid
,
997 .close
= smb2_close_file
,
998 .flush
= smb2_flush_file
,
999 .async_readv
= smb2_async_readv
,
1000 .async_writev
= smb2_async_writev
,
1001 .sync_read
= smb2_sync_read
,
1002 .sync_write
= smb2_sync_write
,
1003 .query_dir_first
= smb2_query_dir_first
,
1004 .query_dir_next
= smb2_query_dir_next
,
1005 .close_dir
= smb2_close_dir
,
1006 .calc_smb_size
= smb2_calc_size
,
1007 .is_status_pending
= smb2_is_status_pending
,
1008 .oplock_response
= smb2_oplock_response
,
1009 .queryfs
= smb2_queryfs
,
1010 .mand_lock
= smb2_mand_lock
,
1011 .mand_unlock_range
= smb2_unlock_range
,
1012 .push_mand_locks
= smb2_push_mandatory_locks
,
1013 .get_lease_key
= smb2_get_lease_key
,
1014 .set_lease_key
= smb2_set_lease_key
,
1015 .new_lease_key
= smb2_new_lease_key
,
1016 .calc_signature
= smb2_calc_signature
,
1017 .is_read_op
= smb21_is_read_op
,
1018 .set_oplock_level
= smb21_set_oplock_level
,
1019 .create_lease_buf
= smb2_create_lease_buf
,
1020 .parse_lease_buf
= smb2_parse_lease_buf
,
1023 struct smb_version_operations smb30_operations
= {
1024 .compare_fids
= smb2_compare_fids
,
1025 .setup_request
= smb2_setup_request
,
1026 .setup_async_request
= smb2_setup_async_request
,
1027 .check_receive
= smb2_check_receive
,
1028 .add_credits
= smb2_add_credits
,
1029 .set_credits
= smb2_set_credits
,
1030 .get_credits_field
= smb2_get_credits_field
,
1031 .get_credits
= smb2_get_credits
,
1032 .get_next_mid
= smb2_get_next_mid
,
1033 .read_data_offset
= smb2_read_data_offset
,
1034 .read_data_length
= smb2_read_data_length
,
1035 .map_error
= map_smb2_to_linux_error
,
1036 .find_mid
= smb2_find_mid
,
1037 .check_message
= smb2_check_message
,
1038 .dump_detail
= smb2_dump_detail
,
1039 .clear_stats
= smb2_clear_stats
,
1040 .print_stats
= smb2_print_stats
,
1041 .dump_share_caps
= smb2_dump_share_caps
,
1042 .is_oplock_break
= smb2_is_valid_oplock_break
,
1043 .need_neg
= smb2_need_neg
,
1044 .negotiate
= smb2_negotiate
,
1045 .negotiate_wsize
= smb2_negotiate_wsize
,
1046 .negotiate_rsize
= smb2_negotiate_rsize
,
1047 .sess_setup
= SMB2_sess_setup
,
1048 .logoff
= SMB2_logoff
,
1049 .tree_connect
= SMB2_tcon
,
1050 .tree_disconnect
= SMB2_tdis
,
1051 .qfs_tcon
= smb2_qfs_tcon
,
1052 .is_path_accessible
= smb2_is_path_accessible
,
1053 .can_echo
= smb2_can_echo
,
1055 .query_path_info
= smb2_query_path_info
,
1056 .get_srv_inum
= smb2_get_srv_inum
,
1057 .query_file_info
= smb2_query_file_info
,
1058 .set_path_size
= smb2_set_path_size
,
1059 .set_file_size
= smb2_set_file_size
,
1060 .set_file_info
= smb2_set_file_info
,
1061 .set_compression
= smb2_set_compression
,
1062 .mkdir
= smb2_mkdir
,
1063 .mkdir_setinfo
= smb2_mkdir_setinfo
,
1064 .rmdir
= smb2_rmdir
,
1065 .unlink
= smb2_unlink
,
1066 .rename
= smb2_rename_path
,
1067 .create_hardlink
= smb2_create_hardlink
,
1068 .query_symlink
= smb2_query_symlink
,
1069 .open
= smb2_open_file
,
1070 .set_fid
= smb2_set_fid
,
1071 .close
= smb2_close_file
,
1072 .flush
= smb2_flush_file
,
1073 .async_readv
= smb2_async_readv
,
1074 .async_writev
= smb2_async_writev
,
1075 .sync_read
= smb2_sync_read
,
1076 .sync_write
= smb2_sync_write
,
1077 .query_dir_first
= smb2_query_dir_first
,
1078 .query_dir_next
= smb2_query_dir_next
,
1079 .close_dir
= smb2_close_dir
,
1080 .calc_smb_size
= smb2_calc_size
,
1081 .is_status_pending
= smb2_is_status_pending
,
1082 .oplock_response
= smb2_oplock_response
,
1083 .queryfs
= smb2_queryfs
,
1084 .mand_lock
= smb2_mand_lock
,
1085 .mand_unlock_range
= smb2_unlock_range
,
1086 .push_mand_locks
= smb2_push_mandatory_locks
,
1087 .get_lease_key
= smb2_get_lease_key
,
1088 .set_lease_key
= smb2_set_lease_key
,
1089 .new_lease_key
= smb2_new_lease_key
,
1090 .generate_signingkey
= generate_smb3signingkey
,
1091 .calc_signature
= smb3_calc_signature
,
1092 .is_read_op
= smb21_is_read_op
,
1093 .set_oplock_level
= smb3_set_oplock_level
,
1094 .create_lease_buf
= smb3_create_lease_buf
,
1095 .parse_lease_buf
= smb3_parse_lease_buf
,
1098 struct smb_version_values smb20_values
= {
1099 .version_string
= SMB20_VERSION_STRING
,
1100 .protocol_id
= SMB20_PROT_ID
,
1101 .req_capabilities
= 0, /* MBZ */
1102 .large_lock_type
= 0,
1103 .exclusive_lock_type
= SMB2_LOCKFLAG_EXCLUSIVE_LOCK
,
1104 .shared_lock_type
= SMB2_LOCKFLAG_SHARED_LOCK
,
1105 .unlock_lock_type
= SMB2_LOCKFLAG_UNLOCK
,
1106 .header_size
= sizeof(struct smb2_hdr
),
1107 .max_header_size
= MAX_SMB2_HDR_SIZE
,
1108 .read_rsp_size
= sizeof(struct smb2_read_rsp
) - 1,
1109 .lock_cmd
= SMB2_LOCK
,
1111 .cap_nt_find
= SMB2_NT_FIND
,
1112 .cap_large_files
= SMB2_LARGE_FILES
,
1113 .signing_enabled
= SMB2_NEGOTIATE_SIGNING_ENABLED
| SMB2_NEGOTIATE_SIGNING_REQUIRED
,
1114 .signing_required
= SMB2_NEGOTIATE_SIGNING_REQUIRED
,
1115 .create_lease_size
= sizeof(struct create_lease
),
1118 struct smb_version_values smb21_values
= {
1119 .version_string
= SMB21_VERSION_STRING
,
1120 .protocol_id
= SMB21_PROT_ID
,
1121 .req_capabilities
= 0, /* MBZ on negotiate req until SMB3 dialect */
1122 .large_lock_type
= 0,
1123 .exclusive_lock_type
= SMB2_LOCKFLAG_EXCLUSIVE_LOCK
,
1124 .shared_lock_type
= SMB2_LOCKFLAG_SHARED_LOCK
,
1125 .unlock_lock_type
= SMB2_LOCKFLAG_UNLOCK
,
1126 .header_size
= sizeof(struct smb2_hdr
),
1127 .max_header_size
= MAX_SMB2_HDR_SIZE
,
1128 .read_rsp_size
= sizeof(struct smb2_read_rsp
) - 1,
1129 .lock_cmd
= SMB2_LOCK
,
1131 .cap_nt_find
= SMB2_NT_FIND
,
1132 .cap_large_files
= SMB2_LARGE_FILES
,
1133 .signing_enabled
= SMB2_NEGOTIATE_SIGNING_ENABLED
| SMB2_NEGOTIATE_SIGNING_REQUIRED
,
1134 .signing_required
= SMB2_NEGOTIATE_SIGNING_REQUIRED
,
1135 .create_lease_size
= sizeof(struct create_lease
),
1138 struct smb_version_values smb30_values
= {
1139 .version_string
= SMB30_VERSION_STRING
,
1140 .protocol_id
= SMB30_PROT_ID
,
1141 .req_capabilities
= SMB2_GLOBAL_CAP_DFS
| SMB2_GLOBAL_CAP_LEASING
| SMB2_GLOBAL_CAP_LARGE_MTU
,
1142 .large_lock_type
= 0,
1143 .exclusive_lock_type
= SMB2_LOCKFLAG_EXCLUSIVE_LOCK
,
1144 .shared_lock_type
= SMB2_LOCKFLAG_SHARED_LOCK
,
1145 .unlock_lock_type
= SMB2_LOCKFLAG_UNLOCK
,
1146 .header_size
= sizeof(struct smb2_hdr
),
1147 .max_header_size
= MAX_SMB2_HDR_SIZE
,
1148 .read_rsp_size
= sizeof(struct smb2_read_rsp
) - 1,
1149 .lock_cmd
= SMB2_LOCK
,
1151 .cap_nt_find
= SMB2_NT_FIND
,
1152 .cap_large_files
= SMB2_LARGE_FILES
,
1153 .signing_enabled
= SMB2_NEGOTIATE_SIGNING_ENABLED
| SMB2_NEGOTIATE_SIGNING_REQUIRED
,
1154 .signing_required
= SMB2_NEGOTIATE_SIGNING_REQUIRED
,
1155 .create_lease_size
= sizeof(struct create_lease_v2
),
1158 struct smb_version_values smb302_values
= {
1159 .version_string
= SMB302_VERSION_STRING
,
1160 .protocol_id
= SMB302_PROT_ID
,
1161 .req_capabilities
= SMB2_GLOBAL_CAP_DFS
| SMB2_GLOBAL_CAP_LEASING
| SMB2_GLOBAL_CAP_LARGE_MTU
,
1162 .large_lock_type
= 0,
1163 .exclusive_lock_type
= SMB2_LOCKFLAG_EXCLUSIVE_LOCK
,
1164 .shared_lock_type
= SMB2_LOCKFLAG_SHARED_LOCK
,
1165 .unlock_lock_type
= SMB2_LOCKFLAG_UNLOCK
,
1166 .header_size
= sizeof(struct smb2_hdr
),
1167 .max_header_size
= MAX_SMB2_HDR_SIZE
,
1168 .read_rsp_size
= sizeof(struct smb2_read_rsp
) - 1,
1169 .lock_cmd
= SMB2_LOCK
,
1171 .cap_nt_find
= SMB2_NT_FIND
,
1172 .cap_large_files
= SMB2_LARGE_FILES
,
1173 .signing_enabled
= SMB2_NEGOTIATE_SIGNING_ENABLED
| SMB2_NEGOTIATE_SIGNING_REQUIRED
,
1174 .signing_required
= SMB2_NEGOTIATE_SIGNING_REQUIRED
,
1175 .create_lease_size
= sizeof(struct create_lease_v2
),