1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Copyright (C) 2016 Namjae Jeon <linkinjeon@kernel.org>
4 * Copyright (C) 2018 Samsung Electronics Co., Ltd.
7 #include <linux/moduleparam.h>
12 #include "smb_common.h"
13 #include "smbstatus.h"
14 #include "connection.h"
15 #include "mgmt/user_session.h"
16 #include "mgmt/share_config.h"
17 #include "mgmt/tree_connect.h"
19 static LIST_HEAD(lease_table_list
);
20 static DEFINE_RWLOCK(lease_list_lock
);
23 * alloc_opinfo() - allocate a new opinfo object for oplock info
25 * @id: fid of open file
26 * @Tid: tree id of connection
28 * Return: allocated opinfo object on success, otherwise NULL
30 static struct oplock_info
*alloc_opinfo(struct ksmbd_work
*work
,
33 struct ksmbd_conn
*conn
= work
->conn
;
34 struct ksmbd_session
*sess
= work
->sess
;
35 struct oplock_info
*opinfo
;
37 opinfo
= kzalloc(sizeof(struct oplock_info
), GFP_KERNEL
);
43 opinfo
->level
= SMB2_OPLOCK_LEVEL_NONE
;
44 opinfo
->op_state
= OPLOCK_STATE_NONE
;
45 opinfo
->pending_break
= 0;
48 INIT_LIST_HEAD(&opinfo
->op_entry
);
49 INIT_LIST_HEAD(&opinfo
->interim_list
);
50 init_waitqueue_head(&opinfo
->oplock_q
);
51 init_waitqueue_head(&opinfo
->oplock_brk
);
52 atomic_set(&opinfo
->refcount
, 1);
53 atomic_set(&opinfo
->breaking_cnt
, 0);
58 static void lease_add_list(struct oplock_info
*opinfo
)
60 struct lease_table
*lb
= opinfo
->o_lease
->l_lb
;
62 spin_lock(&lb
->lb_lock
);
63 list_add_rcu(&opinfo
->lease_entry
, &lb
->lease_list
);
64 spin_unlock(&lb
->lb_lock
);
67 static void lease_del_list(struct oplock_info
*opinfo
)
69 struct lease_table
*lb
= opinfo
->o_lease
->l_lb
;
74 spin_lock(&lb
->lb_lock
);
75 if (list_empty(&opinfo
->lease_entry
)) {
76 spin_unlock(&lb
->lb_lock
);
80 list_del_init(&opinfo
->lease_entry
);
81 opinfo
->o_lease
->l_lb
= NULL
;
82 spin_unlock(&lb
->lb_lock
);
85 static void lb_add(struct lease_table
*lb
)
87 write_lock(&lease_list_lock
);
88 list_add(&lb
->l_entry
, &lease_table_list
);
89 write_unlock(&lease_list_lock
);
92 static int alloc_lease(struct oplock_info
*opinfo
, struct lease_ctx_info
*lctx
)
96 lease
= kmalloc(sizeof(struct lease
), GFP_KERNEL
);
100 memcpy(lease
->lease_key
, lctx
->lease_key
, SMB2_LEASE_KEY_SIZE
);
101 lease
->state
= lctx
->req_state
;
102 lease
->new_state
= 0;
103 lease
->flags
= lctx
->flags
;
104 lease
->duration
= lctx
->duration
;
105 lease
->is_dir
= lctx
->is_dir
;
106 memcpy(lease
->parent_lease_key
, lctx
->parent_lease_key
, SMB2_LEASE_KEY_SIZE
);
107 lease
->version
= lctx
->version
;
108 lease
->epoch
= le16_to_cpu(lctx
->epoch
);
109 INIT_LIST_HEAD(&opinfo
->lease_entry
);
110 opinfo
->o_lease
= lease
;
115 static void free_lease(struct oplock_info
*opinfo
)
119 lease
= opinfo
->o_lease
;
123 static void free_opinfo(struct oplock_info
*opinfo
)
125 if (opinfo
->is_lease
)
130 static inline void opinfo_free_rcu(struct rcu_head
*rcu_head
)
132 struct oplock_info
*opinfo
;
134 opinfo
= container_of(rcu_head
, struct oplock_info
, rcu_head
);
138 struct oplock_info
*opinfo_get(struct ksmbd_file
*fp
)
140 struct oplock_info
*opinfo
;
143 opinfo
= rcu_dereference(fp
->f_opinfo
);
144 if (opinfo
&& !atomic_inc_not_zero(&opinfo
->refcount
))
151 static struct oplock_info
*opinfo_get_list(struct ksmbd_inode
*ci
)
153 struct oplock_info
*opinfo
;
155 if (list_empty(&ci
->m_op_list
))
159 opinfo
= list_first_or_null_rcu(&ci
->m_op_list
, struct oplock_info
,
162 if (!atomic_inc_not_zero(&opinfo
->refcount
))
165 atomic_inc(&opinfo
->conn
->r_count
);
166 if (ksmbd_conn_releasing(opinfo
->conn
)) {
167 atomic_dec(&opinfo
->conn
->r_count
);
168 atomic_dec(&opinfo
->refcount
);
179 static void opinfo_conn_put(struct oplock_info
*opinfo
)
181 struct ksmbd_conn
*conn
;
188 * Checking waitqueue to dropping pending requests on
189 * disconnection. waitqueue_active is safe because it
190 * uses atomic operation for condition.
192 if (!atomic_dec_return(&conn
->r_count
) && waitqueue_active(&conn
->r_count_q
))
193 wake_up(&conn
->r_count_q
);
197 void opinfo_put(struct oplock_info
*opinfo
)
199 if (!atomic_dec_and_test(&opinfo
->refcount
))
202 call_rcu(&opinfo
->rcu_head
, opinfo_free_rcu
);
205 static void opinfo_add(struct oplock_info
*opinfo
)
207 struct ksmbd_inode
*ci
= opinfo
->o_fp
->f_ci
;
209 write_lock(&ci
->m_lock
);
210 list_add_rcu(&opinfo
->op_entry
, &ci
->m_op_list
);
211 write_unlock(&ci
->m_lock
);
214 static void opinfo_del(struct oplock_info
*opinfo
)
216 struct ksmbd_inode
*ci
= opinfo
->o_fp
->f_ci
;
218 if (opinfo
->is_lease
) {
219 write_lock(&lease_list_lock
);
220 lease_del_list(opinfo
);
221 write_unlock(&lease_list_lock
);
223 write_lock(&ci
->m_lock
);
224 list_del_rcu(&opinfo
->op_entry
);
225 write_unlock(&ci
->m_lock
);
228 static unsigned long opinfo_count(struct ksmbd_file
*fp
)
230 if (ksmbd_stream_fd(fp
))
231 return atomic_read(&fp
->f_ci
->sop_count
);
233 return atomic_read(&fp
->f_ci
->op_count
);
236 static void opinfo_count_inc(struct ksmbd_file
*fp
)
238 if (ksmbd_stream_fd(fp
))
239 return atomic_inc(&fp
->f_ci
->sop_count
);
241 return atomic_inc(&fp
->f_ci
->op_count
);
244 static void opinfo_count_dec(struct ksmbd_file
*fp
)
246 if (ksmbd_stream_fd(fp
))
247 return atomic_dec(&fp
->f_ci
->sop_count
);
249 return atomic_dec(&fp
->f_ci
->op_count
);
253 * opinfo_write_to_read() - convert a write oplock to read oplock
254 * @opinfo: current oplock info
256 * Return: 0 on success, otherwise -EINVAL
258 int opinfo_write_to_read(struct oplock_info
*opinfo
)
260 struct lease
*lease
= opinfo
->o_lease
;
262 if (!(opinfo
->level
== SMB2_OPLOCK_LEVEL_BATCH
||
263 opinfo
->level
== SMB2_OPLOCK_LEVEL_EXCLUSIVE
)) {
264 pr_err("bad oplock(0x%x)\n", opinfo
->level
);
265 if (opinfo
->is_lease
)
266 pr_err("lease state(0x%x)\n", lease
->state
);
269 opinfo
->level
= SMB2_OPLOCK_LEVEL_II
;
271 if (opinfo
->is_lease
)
272 lease
->state
= lease
->new_state
;
277 * opinfo_read_handle_to_read() - convert a read/handle oplock to read oplock
278 * @opinfo: current oplock info
280 * Return: 0 on success, otherwise -EINVAL
282 int opinfo_read_handle_to_read(struct oplock_info
*opinfo
)
284 struct lease
*lease
= opinfo
->o_lease
;
286 lease
->state
= lease
->new_state
;
287 opinfo
->level
= SMB2_OPLOCK_LEVEL_II
;
292 * opinfo_write_to_none() - convert a write oplock to none
293 * @opinfo: current oplock info
295 * Return: 0 on success, otherwise -EINVAL
297 int opinfo_write_to_none(struct oplock_info
*opinfo
)
299 struct lease
*lease
= opinfo
->o_lease
;
301 if (!(opinfo
->level
== SMB2_OPLOCK_LEVEL_BATCH
||
302 opinfo
->level
== SMB2_OPLOCK_LEVEL_EXCLUSIVE
)) {
303 pr_err("bad oplock(0x%x)\n", opinfo
->level
);
304 if (opinfo
->is_lease
)
305 pr_err("lease state(0x%x)\n", lease
->state
);
308 opinfo
->level
= SMB2_OPLOCK_LEVEL_NONE
;
309 if (opinfo
->is_lease
)
310 lease
->state
= lease
->new_state
;
315 * opinfo_read_to_none() - convert a write read to none
316 * @opinfo: current oplock info
318 * Return: 0 on success, otherwise -EINVAL
320 int opinfo_read_to_none(struct oplock_info
*opinfo
)
322 struct lease
*lease
= opinfo
->o_lease
;
324 if (opinfo
->level
!= SMB2_OPLOCK_LEVEL_II
) {
325 pr_err("bad oplock(0x%x)\n", opinfo
->level
);
326 if (opinfo
->is_lease
)
327 pr_err("lease state(0x%x)\n", lease
->state
);
330 opinfo
->level
= SMB2_OPLOCK_LEVEL_NONE
;
331 if (opinfo
->is_lease
)
332 lease
->state
= lease
->new_state
;
337 * lease_read_to_write() - upgrade lease state from read to write
338 * @opinfo: current lease info
340 * Return: 0 on success, otherwise -EINVAL
342 int lease_read_to_write(struct oplock_info
*opinfo
)
344 struct lease
*lease
= opinfo
->o_lease
;
346 if (!(lease
->state
& SMB2_LEASE_READ_CACHING_LE
)) {
347 ksmbd_debug(OPLOCK
, "bad lease state(0x%x)\n", lease
->state
);
351 lease
->new_state
= SMB2_LEASE_NONE_LE
;
352 lease
->state
|= SMB2_LEASE_WRITE_CACHING_LE
;
353 if (lease
->state
& SMB2_LEASE_HANDLE_CACHING_LE
)
354 opinfo
->level
= SMB2_OPLOCK_LEVEL_BATCH
;
356 opinfo
->level
= SMB2_OPLOCK_LEVEL_EXCLUSIVE
;
361 * lease_none_upgrade() - upgrade lease state from none
362 * @opinfo: current lease info
363 * @new_state: new lease state
365 * Return: 0 on success, otherwise -EINVAL
367 static int lease_none_upgrade(struct oplock_info
*opinfo
, __le32 new_state
)
369 struct lease
*lease
= opinfo
->o_lease
;
371 if (!(lease
->state
== SMB2_LEASE_NONE_LE
)) {
372 ksmbd_debug(OPLOCK
, "bad lease state(0x%x)\n", lease
->state
);
376 lease
->new_state
= SMB2_LEASE_NONE_LE
;
377 lease
->state
= new_state
;
378 if (lease
->state
& SMB2_LEASE_HANDLE_CACHING_LE
)
379 if (lease
->state
& SMB2_LEASE_WRITE_CACHING_LE
)
380 opinfo
->level
= SMB2_OPLOCK_LEVEL_BATCH
;
382 opinfo
->level
= SMB2_OPLOCK_LEVEL_II
;
383 else if (lease
->state
& SMB2_LEASE_WRITE_CACHING_LE
)
384 opinfo
->level
= SMB2_OPLOCK_LEVEL_EXCLUSIVE
;
385 else if (lease
->state
& SMB2_LEASE_READ_CACHING_LE
)
386 opinfo
->level
= SMB2_OPLOCK_LEVEL_II
;
392 * close_id_del_oplock() - release oplock object at file close time
393 * @fp: ksmbd file pointer
395 void close_id_del_oplock(struct ksmbd_file
*fp
)
397 struct oplock_info
*opinfo
;
399 if (fp
->reserve_lease_break
)
400 smb_lazy_parent_lease_break_close(fp
);
402 opinfo
= opinfo_get(fp
);
408 rcu_assign_pointer(fp
->f_opinfo
, NULL
);
409 if (opinfo
->op_state
== OPLOCK_ACK_WAIT
) {
410 opinfo
->op_state
= OPLOCK_CLOSING
;
411 wake_up_interruptible_all(&opinfo
->oplock_q
);
412 if (opinfo
->is_lease
) {
413 atomic_set(&opinfo
->breaking_cnt
, 0);
414 wake_up_interruptible_all(&opinfo
->oplock_brk
);
418 opinfo_count_dec(fp
);
419 atomic_dec(&opinfo
->refcount
);
424 * grant_write_oplock() - grant exclusive/batch oplock or write lease
425 * @opinfo_new: new oplock info object
426 * @req_oplock: request oplock
427 * @lctx: lease context information
431 static void grant_write_oplock(struct oplock_info
*opinfo_new
, int req_oplock
,
432 struct lease_ctx_info
*lctx
)
434 struct lease
*lease
= opinfo_new
->o_lease
;
436 if (req_oplock
== SMB2_OPLOCK_LEVEL_BATCH
)
437 opinfo_new
->level
= SMB2_OPLOCK_LEVEL_BATCH
;
439 opinfo_new
->level
= SMB2_OPLOCK_LEVEL_EXCLUSIVE
;
442 lease
->state
= lctx
->req_state
;
443 memcpy(lease
->lease_key
, lctx
->lease_key
, SMB2_LEASE_KEY_SIZE
);
448 * grant_read_oplock() - grant level2 oplock or read lease
449 * @opinfo_new: new oplock info object
450 * @lctx: lease context information
454 static void grant_read_oplock(struct oplock_info
*opinfo_new
,
455 struct lease_ctx_info
*lctx
)
457 struct lease
*lease
= opinfo_new
->o_lease
;
459 opinfo_new
->level
= SMB2_OPLOCK_LEVEL_II
;
462 lease
->state
= SMB2_LEASE_READ_CACHING_LE
;
463 if (lctx
->req_state
& SMB2_LEASE_HANDLE_CACHING_LE
)
464 lease
->state
|= SMB2_LEASE_HANDLE_CACHING_LE
;
465 memcpy(lease
->lease_key
, lctx
->lease_key
, SMB2_LEASE_KEY_SIZE
);
470 * grant_none_oplock() - grant none oplock or none lease
471 * @opinfo_new: new oplock info object
472 * @lctx: lease context information
476 static void grant_none_oplock(struct oplock_info
*opinfo_new
,
477 struct lease_ctx_info
*lctx
)
479 struct lease
*lease
= opinfo_new
->o_lease
;
481 opinfo_new
->level
= SMB2_OPLOCK_LEVEL_NONE
;
485 memcpy(lease
->lease_key
, lctx
->lease_key
, SMB2_LEASE_KEY_SIZE
);
489 static inline int compare_guid_key(struct oplock_info
*opinfo
,
490 const char *guid1
, const char *key1
)
492 const char *guid2
, *key2
;
494 guid2
= opinfo
->conn
->ClientGUID
;
495 key2
= opinfo
->o_lease
->lease_key
;
496 if (!memcmp(guid1
, guid2
, SMB2_CLIENT_GUID_SIZE
) &&
497 !memcmp(key1
, key2
, SMB2_LEASE_KEY_SIZE
))
504 * same_client_has_lease() - check whether current lease request is
505 * from lease owner of file
506 * @ci: master file pointer
507 * @client_guid: Client GUID
508 * @lctx: lease context information
510 * Return: oplock(lease) object on success, otherwise NULL
512 static struct oplock_info
*same_client_has_lease(struct ksmbd_inode
*ci
,
514 struct lease_ctx_info
*lctx
)
518 struct oplock_info
*opinfo
;
519 struct oplock_info
*m_opinfo
= NULL
;
525 * Compare lease key and client_guid to know request from same owner
528 read_lock(&ci
->m_lock
);
529 list_for_each_entry(opinfo
, &ci
->m_op_list
, op_entry
) {
530 if (!opinfo
->is_lease
)
532 read_unlock(&ci
->m_lock
);
533 lease
= opinfo
->o_lease
;
535 ret
= compare_guid_key(opinfo
, client_guid
, lctx
->lease_key
);
538 /* skip upgrading lease about breaking lease */
539 if (atomic_read(&opinfo
->breaking_cnt
)) {
540 read_lock(&ci
->m_lock
);
544 /* upgrading lease */
545 if ((atomic_read(&ci
->op_count
) +
546 atomic_read(&ci
->sop_count
)) == 1) {
547 if (lease
->state
!= SMB2_LEASE_NONE_LE
&&
548 lease
->state
== (lctx
->req_state
& lease
->state
)) {
549 lease
->state
|= lctx
->req_state
;
550 if (lctx
->req_state
&
551 SMB2_LEASE_WRITE_CACHING_LE
)
552 lease_read_to_write(opinfo
);
555 } else if ((atomic_read(&ci
->op_count
) +
556 atomic_read(&ci
->sop_count
)) > 1) {
557 if (lctx
->req_state
==
558 (SMB2_LEASE_READ_CACHING_LE
|
559 SMB2_LEASE_HANDLE_CACHING_LE
))
560 lease
->state
= lctx
->req_state
;
563 if (lctx
->req_state
&& lease
->state
==
565 lease_none_upgrade(opinfo
, lctx
->req_state
);
567 read_lock(&ci
->m_lock
);
569 read_unlock(&ci
->m_lock
);
574 static void wait_for_break_ack(struct oplock_info
*opinfo
)
578 rc
= wait_event_interruptible_timeout(opinfo
->oplock_q
,
579 opinfo
->op_state
== OPLOCK_STATE_NONE
||
580 opinfo
->op_state
== OPLOCK_CLOSING
,
583 /* is this a timeout ? */
585 if (opinfo
->is_lease
)
586 opinfo
->o_lease
->state
= SMB2_LEASE_NONE_LE
;
587 opinfo
->level
= SMB2_OPLOCK_LEVEL_NONE
;
588 opinfo
->op_state
= OPLOCK_STATE_NONE
;
592 static void wake_up_oplock_break(struct oplock_info
*opinfo
)
594 clear_bit_unlock(0, &opinfo
->pending_break
);
595 /* memory barrier is needed for wake_up_bit() */
596 smp_mb__after_atomic();
597 wake_up_bit(&opinfo
->pending_break
, 0);
600 static int oplock_break_pending(struct oplock_info
*opinfo
, int req_op_level
)
602 while (test_and_set_bit(0, &opinfo
->pending_break
)) {
603 wait_on_bit(&opinfo
->pending_break
, 0, TASK_UNINTERRUPTIBLE
);
605 /* Not immediately break to none. */
606 opinfo
->open_trunc
= 0;
608 if (opinfo
->op_state
== OPLOCK_CLOSING
)
610 else if (!opinfo
->is_lease
&& opinfo
->level
<= req_op_level
)
614 if (!opinfo
->is_lease
&& opinfo
->level
<= req_op_level
) {
615 wake_up_oplock_break(opinfo
);
622 * __smb2_oplock_break_noti() - send smb2 oplock break cmd from conn
624 * @wk: smb work object
626 * There are two ways this function can be called. 1- while file open we break
627 * from exclusive/batch lock to levelII oplock and 2- while file write/truncate
628 * we break from levelII oplock no oplock.
629 * work->request_buf contains oplock_info.
631 static void __smb2_oplock_break_noti(struct work_struct
*wk
)
633 struct smb2_oplock_break
*rsp
= NULL
;
634 struct ksmbd_work
*work
= container_of(wk
, struct ksmbd_work
, work
);
635 struct oplock_break_info
*br_info
= work
->request_buf
;
636 struct smb2_hdr
*rsp_hdr
;
637 struct ksmbd_file
*fp
;
639 fp
= ksmbd_lookup_durable_fd(br_info
->fid
);
643 if (allocate_interim_rsp_buf(work
)) {
644 pr_err("smb2_allocate_rsp_buf failed! ");
645 ksmbd_fd_put(work
, fp
);
649 rsp_hdr
= smb2_get_msg(work
->response_buf
);
650 memset(rsp_hdr
, 0, sizeof(struct smb2_hdr
) + 2);
651 rsp_hdr
->ProtocolId
= SMB2_PROTO_NUMBER
;
652 rsp_hdr
->StructureSize
= SMB2_HEADER_STRUCTURE_SIZE
;
653 rsp_hdr
->CreditRequest
= cpu_to_le16(0);
654 rsp_hdr
->Command
= SMB2_OPLOCK_BREAK
;
655 rsp_hdr
->Flags
= (SMB2_FLAGS_SERVER_TO_REDIR
);
656 rsp_hdr
->NextCommand
= 0;
657 rsp_hdr
->MessageId
= cpu_to_le64(-1);
658 rsp_hdr
->Id
.SyncId
.ProcessId
= 0;
659 rsp_hdr
->Id
.SyncId
.TreeId
= 0;
660 rsp_hdr
->SessionId
= 0;
661 memset(rsp_hdr
->Signature
, 0, 16);
663 rsp
= smb2_get_msg(work
->response_buf
);
665 rsp
->StructureSize
= cpu_to_le16(24);
666 if (!br_info
->open_trunc
&&
667 (br_info
->level
== SMB2_OPLOCK_LEVEL_BATCH
||
668 br_info
->level
== SMB2_OPLOCK_LEVEL_EXCLUSIVE
))
669 rsp
->OplockLevel
= SMB2_OPLOCK_LEVEL_II
;
671 rsp
->OplockLevel
= SMB2_OPLOCK_LEVEL_NONE
;
674 rsp
->PersistentFid
= fp
->persistent_id
;
675 rsp
->VolatileFid
= fp
->volatile_id
;
677 ksmbd_fd_put(work
, fp
);
678 if (ksmbd_iov_pin_rsp(work
, (void *)rsp
,
679 sizeof(struct smb2_oplock_break
)))
683 "sending oplock break v_id %llu p_id = %llu lock level = %d\n",
684 rsp
->VolatileFid
, rsp
->PersistentFid
, rsp
->OplockLevel
);
686 ksmbd_conn_write(work
);
689 ksmbd_free_work_struct(work
);
693 * smb2_oplock_break_noti() - send smb2 exclusive/batch to level2 oplock
694 * break command from server to client
695 * @opinfo: oplock info object
697 * Return: 0 on success, otherwise error
699 static int smb2_oplock_break_noti(struct oplock_info
*opinfo
)
701 struct ksmbd_conn
*conn
= opinfo
->conn
;
702 struct oplock_break_info
*br_info
;
704 struct ksmbd_work
*work
= ksmbd_alloc_work_struct();
709 br_info
= kmalloc(sizeof(struct oplock_break_info
), GFP_KERNEL
);
711 ksmbd_free_work_struct(work
);
715 br_info
->level
= opinfo
->level
;
716 br_info
->fid
= opinfo
->fid
;
717 br_info
->open_trunc
= opinfo
->open_trunc
;
719 work
->request_buf
= (char *)br_info
;
721 work
->sess
= opinfo
->sess
;
723 if (opinfo
->op_state
== OPLOCK_ACK_WAIT
) {
724 INIT_WORK(&work
->work
, __smb2_oplock_break_noti
);
725 ksmbd_queue_work(work
);
727 wait_for_break_ack(opinfo
);
729 __smb2_oplock_break_noti(&work
->work
);
730 if (opinfo
->level
== SMB2_OPLOCK_LEVEL_II
)
731 opinfo
->level
= SMB2_OPLOCK_LEVEL_NONE
;
737 * __smb2_lease_break_noti() - send lease break command from server
739 * @wk: smb work object
741 static void __smb2_lease_break_noti(struct work_struct
*wk
)
743 struct smb2_lease_break
*rsp
= NULL
;
744 struct ksmbd_work
*work
= container_of(wk
, struct ksmbd_work
, work
);
745 struct lease_break_info
*br_info
= work
->request_buf
;
746 struct smb2_hdr
*rsp_hdr
;
748 if (allocate_interim_rsp_buf(work
)) {
749 ksmbd_debug(OPLOCK
, "smb2_allocate_rsp_buf failed! ");
753 rsp_hdr
= smb2_get_msg(work
->response_buf
);
754 memset(rsp_hdr
, 0, sizeof(struct smb2_hdr
) + 2);
755 rsp_hdr
->ProtocolId
= SMB2_PROTO_NUMBER
;
756 rsp_hdr
->StructureSize
= SMB2_HEADER_STRUCTURE_SIZE
;
757 rsp_hdr
->CreditRequest
= cpu_to_le16(0);
758 rsp_hdr
->Command
= SMB2_OPLOCK_BREAK
;
759 rsp_hdr
->Flags
= (SMB2_FLAGS_SERVER_TO_REDIR
);
760 rsp_hdr
->NextCommand
= 0;
761 rsp_hdr
->MessageId
= cpu_to_le64(-1);
762 rsp_hdr
->Id
.SyncId
.ProcessId
= 0;
763 rsp_hdr
->Id
.SyncId
.TreeId
= 0;
764 rsp_hdr
->SessionId
= 0;
765 memset(rsp_hdr
->Signature
, 0, 16);
767 rsp
= smb2_get_msg(work
->response_buf
);
768 rsp
->StructureSize
= cpu_to_le16(44);
769 rsp
->Epoch
= br_info
->epoch
;
772 if (br_info
->curr_state
& (SMB2_LEASE_WRITE_CACHING_LE
|
773 SMB2_LEASE_HANDLE_CACHING_LE
))
774 rsp
->Flags
= SMB2_NOTIFY_BREAK_LEASE_FLAG_ACK_REQUIRED
;
776 memcpy(rsp
->LeaseKey
, br_info
->lease_key
, SMB2_LEASE_KEY_SIZE
);
777 rsp
->CurrentLeaseState
= br_info
->curr_state
;
778 rsp
->NewLeaseState
= br_info
->new_state
;
779 rsp
->BreakReason
= 0;
780 rsp
->AccessMaskHint
= 0;
781 rsp
->ShareMaskHint
= 0;
783 if (ksmbd_iov_pin_rsp(work
, (void *)rsp
,
784 sizeof(struct smb2_lease_break
)))
787 ksmbd_conn_write(work
);
790 ksmbd_free_work_struct(work
);
794 * smb2_lease_break_noti() - break lease when a new client request
796 * @opinfo: conains lease state information
798 * Return: 0 on success, otherwise error
800 static int smb2_lease_break_noti(struct oplock_info
*opinfo
)
802 struct ksmbd_conn
*conn
= opinfo
->conn
;
803 struct list_head
*tmp
, *t
;
804 struct ksmbd_work
*work
;
805 struct lease_break_info
*br_info
;
806 struct lease
*lease
= opinfo
->o_lease
;
808 work
= ksmbd_alloc_work_struct();
812 br_info
= kmalloc(sizeof(struct lease_break_info
), GFP_KERNEL
);
814 ksmbd_free_work_struct(work
);
818 br_info
->curr_state
= lease
->state
;
819 br_info
->new_state
= lease
->new_state
;
820 if (lease
->version
== 2)
821 br_info
->epoch
= cpu_to_le16(++lease
->epoch
);
824 memcpy(br_info
->lease_key
, lease
->lease_key
, SMB2_LEASE_KEY_SIZE
);
826 work
->request_buf
= (char *)br_info
;
828 work
->sess
= opinfo
->sess
;
830 if (opinfo
->op_state
== OPLOCK_ACK_WAIT
) {
831 list_for_each_safe(tmp
, t
, &opinfo
->interim_list
) {
832 struct ksmbd_work
*in_work
;
834 in_work
= list_entry(tmp
, struct ksmbd_work
,
836 setup_async_work(in_work
, NULL
, NULL
);
837 smb2_send_interim_resp(in_work
, STATUS_PENDING
);
838 list_del_init(&in_work
->interim_entry
);
839 release_async_work(in_work
);
841 INIT_WORK(&work
->work
, __smb2_lease_break_noti
);
842 ksmbd_queue_work(work
);
843 wait_for_break_ack(opinfo
);
845 __smb2_lease_break_noti(&work
->work
);
846 if (opinfo
->o_lease
->new_state
== SMB2_LEASE_NONE_LE
) {
847 opinfo
->level
= SMB2_OPLOCK_LEVEL_NONE
;
848 opinfo
->o_lease
->state
= SMB2_LEASE_NONE_LE
;
854 static void wait_lease_breaking(struct oplock_info
*opinfo
)
856 if (!opinfo
->is_lease
)
859 wake_up_interruptible_all(&opinfo
->oplock_brk
);
860 if (atomic_read(&opinfo
->breaking_cnt
)) {
863 ret
= wait_event_interruptible_timeout(opinfo
->oplock_brk
,
864 atomic_read(&opinfo
->breaking_cnt
) == 0,
867 atomic_set(&opinfo
->breaking_cnt
, 0);
871 static int oplock_break(struct oplock_info
*brk_opinfo
, int req_op_level
)
875 /* Need to break exclusive/batch oplock, write lease or overwrite_if */
877 "request to send oplock(level : 0x%x) break notification\n",
880 if (brk_opinfo
->is_lease
) {
881 struct lease
*lease
= brk_opinfo
->o_lease
;
883 atomic_inc(&brk_opinfo
->breaking_cnt
);
885 err
= oplock_break_pending(brk_opinfo
, req_op_level
);
887 return err
< 0 ? err
: 0;
889 if (brk_opinfo
->open_trunc
) {
891 * Create overwrite break trigger the lease break to
894 lease
->new_state
= SMB2_LEASE_NONE_LE
;
896 if (lease
->state
& SMB2_LEASE_WRITE_CACHING_LE
) {
897 if (lease
->state
& SMB2_LEASE_HANDLE_CACHING_LE
)
899 SMB2_LEASE_READ_CACHING_LE
|
900 SMB2_LEASE_HANDLE_CACHING_LE
;
903 SMB2_LEASE_READ_CACHING_LE
;
905 if (lease
->state
& SMB2_LEASE_HANDLE_CACHING_LE
&&
908 SMB2_LEASE_READ_CACHING_LE
;
910 lease
->new_state
= SMB2_LEASE_NONE_LE
;
914 if (lease
->state
& (SMB2_LEASE_WRITE_CACHING_LE
|
915 SMB2_LEASE_HANDLE_CACHING_LE
))
916 brk_opinfo
->op_state
= OPLOCK_ACK_WAIT
;
918 atomic_dec(&brk_opinfo
->breaking_cnt
);
920 err
= oplock_break_pending(brk_opinfo
, req_op_level
);
922 return err
< 0 ? err
: 0;
924 if (brk_opinfo
->level
== SMB2_OPLOCK_LEVEL_BATCH
||
925 brk_opinfo
->level
== SMB2_OPLOCK_LEVEL_EXCLUSIVE
)
926 brk_opinfo
->op_state
= OPLOCK_ACK_WAIT
;
929 if (brk_opinfo
->is_lease
)
930 err
= smb2_lease_break_noti(brk_opinfo
);
932 err
= smb2_oplock_break_noti(brk_opinfo
);
934 ksmbd_debug(OPLOCK
, "oplock granted = %d\n", brk_opinfo
->level
);
935 if (brk_opinfo
->op_state
== OPLOCK_CLOSING
)
937 wake_up_oplock_break(brk_opinfo
);
939 wait_lease_breaking(brk_opinfo
);
944 void destroy_lease_table(struct ksmbd_conn
*conn
)
946 struct lease_table
*lb
, *lbtmp
;
947 struct oplock_info
*opinfo
;
949 write_lock(&lease_list_lock
);
950 if (list_empty(&lease_table_list
)) {
951 write_unlock(&lease_list_lock
);
955 list_for_each_entry_safe(lb
, lbtmp
, &lease_table_list
, l_entry
) {
956 if (conn
&& memcmp(lb
->client_guid
, conn
->ClientGUID
,
957 SMB2_CLIENT_GUID_SIZE
))
961 list_for_each_entry_rcu(opinfo
, &lb
->lease_list
,
964 lease_del_list(opinfo
);
968 list_del(&lb
->l_entry
);
971 write_unlock(&lease_list_lock
);
974 int find_same_lease_key(struct ksmbd_session
*sess
, struct ksmbd_inode
*ci
,
975 struct lease_ctx_info
*lctx
)
977 struct oplock_info
*opinfo
;
979 struct lease_table
*lb
;
984 read_lock(&lease_list_lock
);
985 if (list_empty(&lease_table_list
)) {
986 read_unlock(&lease_list_lock
);
990 list_for_each_entry(lb
, &lease_table_list
, l_entry
) {
991 if (!memcmp(lb
->client_guid
, sess
->ClientGUID
,
992 SMB2_CLIENT_GUID_SIZE
))
995 read_unlock(&lease_list_lock
);
1001 list_for_each_entry_rcu(opinfo
, &lb
->lease_list
, lease_entry
) {
1002 if (!atomic_inc_not_zero(&opinfo
->refcount
))
1005 if (opinfo
->o_fp
->f_ci
== ci
)
1007 err
= compare_guid_key(opinfo
, sess
->ClientGUID
,
1012 "found same lease key is already used in other files\n");
1023 read_unlock(&lease_list_lock
);
1027 static void copy_lease(struct oplock_info
*op1
, struct oplock_info
*op2
)
1029 struct lease
*lease1
= op1
->o_lease
;
1030 struct lease
*lease2
= op2
->o_lease
;
1032 op2
->level
= op1
->level
;
1033 lease2
->state
= lease1
->state
;
1034 memcpy(lease2
->lease_key
, lease1
->lease_key
,
1035 SMB2_LEASE_KEY_SIZE
);
1036 lease2
->duration
= lease1
->duration
;
1037 lease2
->flags
= lease1
->flags
;
1038 lease2
->epoch
= lease1
->epoch
++;
1041 static int add_lease_global_list(struct oplock_info
*opinfo
)
1043 struct lease_table
*lb
;
1045 read_lock(&lease_list_lock
);
1046 list_for_each_entry(lb
, &lease_table_list
, l_entry
) {
1047 if (!memcmp(lb
->client_guid
, opinfo
->conn
->ClientGUID
,
1048 SMB2_CLIENT_GUID_SIZE
)) {
1049 opinfo
->o_lease
->l_lb
= lb
;
1050 lease_add_list(opinfo
);
1051 read_unlock(&lease_list_lock
);
1055 read_unlock(&lease_list_lock
);
1057 lb
= kmalloc(sizeof(struct lease_table
), GFP_KERNEL
);
1061 memcpy(lb
->client_guid
, opinfo
->conn
->ClientGUID
,
1062 SMB2_CLIENT_GUID_SIZE
);
1063 INIT_LIST_HEAD(&lb
->lease_list
);
1064 spin_lock_init(&lb
->lb_lock
);
1065 opinfo
->o_lease
->l_lb
= lb
;
1066 lease_add_list(opinfo
);
1071 static void set_oplock_level(struct oplock_info
*opinfo
, int level
,
1072 struct lease_ctx_info
*lctx
)
1075 case SMB2_OPLOCK_LEVEL_BATCH
:
1076 case SMB2_OPLOCK_LEVEL_EXCLUSIVE
:
1077 grant_write_oplock(opinfo
, level
, lctx
);
1079 case SMB2_OPLOCK_LEVEL_II
:
1080 grant_read_oplock(opinfo
, lctx
);
1083 grant_none_oplock(opinfo
, lctx
);
1088 void smb_send_parent_lease_break_noti(struct ksmbd_file
*fp
,
1089 struct lease_ctx_info
*lctx
)
1091 struct oplock_info
*opinfo
;
1092 struct ksmbd_inode
*p_ci
= NULL
;
1094 if (lctx
->version
!= 2)
1097 p_ci
= ksmbd_inode_lookup_lock(fp
->filp
->f_path
.dentry
->d_parent
);
1101 read_lock(&p_ci
->m_lock
);
1102 list_for_each_entry(opinfo
, &p_ci
->m_op_list
, op_entry
) {
1103 if (!opinfo
->is_lease
)
1106 if (opinfo
->o_lease
->state
!= SMB2_OPLOCK_LEVEL_NONE
&&
1107 (!(lctx
->flags
& SMB2_LEASE_FLAG_PARENT_LEASE_KEY_SET_LE
) ||
1108 !compare_guid_key(opinfo
, fp
->conn
->ClientGUID
,
1109 lctx
->parent_lease_key
))) {
1110 if (!atomic_inc_not_zero(&opinfo
->refcount
))
1113 atomic_inc(&opinfo
->conn
->r_count
);
1114 if (ksmbd_conn_releasing(opinfo
->conn
)) {
1115 atomic_dec(&opinfo
->conn
->r_count
);
1119 read_unlock(&p_ci
->m_lock
);
1120 oplock_break(opinfo
, SMB2_OPLOCK_LEVEL_NONE
);
1121 opinfo_conn_put(opinfo
);
1122 read_lock(&p_ci
->m_lock
);
1125 read_unlock(&p_ci
->m_lock
);
1127 ksmbd_inode_put(p_ci
);
1130 void smb_lazy_parent_lease_break_close(struct ksmbd_file
*fp
)
1132 struct oplock_info
*opinfo
;
1133 struct ksmbd_inode
*p_ci
= NULL
;
1136 opinfo
= rcu_dereference(fp
->f_opinfo
);
1139 if (!opinfo
->is_lease
|| opinfo
->o_lease
->version
!= 2)
1142 p_ci
= ksmbd_inode_lookup_lock(fp
->filp
->f_path
.dentry
->d_parent
);
1146 read_lock(&p_ci
->m_lock
);
1147 list_for_each_entry(opinfo
, &p_ci
->m_op_list
, op_entry
) {
1148 if (!opinfo
->is_lease
)
1151 if (opinfo
->o_lease
->state
!= SMB2_OPLOCK_LEVEL_NONE
) {
1152 if (!atomic_inc_not_zero(&opinfo
->refcount
))
1155 atomic_inc(&opinfo
->conn
->r_count
);
1156 if (ksmbd_conn_releasing(opinfo
->conn
)) {
1157 atomic_dec(&opinfo
->conn
->r_count
);
1160 read_unlock(&p_ci
->m_lock
);
1161 oplock_break(opinfo
, SMB2_OPLOCK_LEVEL_NONE
);
1162 opinfo_conn_put(opinfo
);
1163 read_lock(&p_ci
->m_lock
);
1166 read_unlock(&p_ci
->m_lock
);
1168 ksmbd_inode_put(p_ci
);
1172 * smb_grant_oplock() - handle oplock/lease request on file open
1174 * @req_op_level: oplock level
1175 * @pid: id of open file
1176 * @fp: ksmbd file pointer
1177 * @tid: Tree id of connection
1178 * @lctx: lease context information on file open
1179 * @share_ret: share mode
1181 * Return: 0 on success, otherwise error
1183 int smb_grant_oplock(struct ksmbd_work
*work
, int req_op_level
, u64 pid
,
1184 struct ksmbd_file
*fp
, __u16 tid
,
1185 struct lease_ctx_info
*lctx
, int share_ret
)
1187 struct ksmbd_session
*sess
= work
->sess
;
1189 struct oplock_info
*opinfo
= NULL
, *prev_opinfo
= NULL
;
1190 struct ksmbd_inode
*ci
= fp
->f_ci
;
1191 bool prev_op_has_lease
;
1192 __le32 prev_op_state
= 0;
1194 opinfo
= alloc_opinfo(work
, pid
, tid
);
1199 err
= alloc_lease(opinfo
, lctx
);
1202 opinfo
->is_lease
= 1;
1205 /* ci does not have any oplock */
1206 if (!opinfo_count(fp
))
1209 /* grant none-oplock if second open is trunc */
1210 if (fp
->attrib_only
&& fp
->cdoption
!= FILE_OVERWRITE_IF_LE
&&
1211 fp
->cdoption
!= FILE_OVERWRITE_LE
&&
1212 fp
->cdoption
!= FILE_SUPERSEDE_LE
) {
1213 req_op_level
= SMB2_OPLOCK_LEVEL_NONE
;
1218 struct oplock_info
*m_opinfo
;
1220 /* is lease already granted ? */
1221 m_opinfo
= same_client_has_lease(ci
, sess
->ClientGUID
,
1224 copy_lease(m_opinfo
, opinfo
);
1225 if (atomic_read(&m_opinfo
->breaking_cnt
))
1226 opinfo
->o_lease
->flags
=
1227 SMB2_LEASE_FLAG_BREAK_IN_PROGRESS_LE
;
1231 prev_opinfo
= opinfo_get_list(ci
);
1233 (prev_opinfo
->level
== SMB2_OPLOCK_LEVEL_NONE
&& lctx
)) {
1234 opinfo_conn_put(prev_opinfo
);
1237 prev_op_has_lease
= prev_opinfo
->is_lease
;
1238 if (prev_op_has_lease
)
1239 prev_op_state
= prev_opinfo
->o_lease
->state
;
1241 if (share_ret
< 0 &&
1242 prev_opinfo
->level
== SMB2_OPLOCK_LEVEL_EXCLUSIVE
) {
1244 opinfo_conn_put(prev_opinfo
);
1248 if (prev_opinfo
->level
!= SMB2_OPLOCK_LEVEL_BATCH
&&
1249 prev_opinfo
->level
!= SMB2_OPLOCK_LEVEL_EXCLUSIVE
) {
1250 opinfo_conn_put(prev_opinfo
);
1251 goto op_break_not_needed
;
1254 list_add(&work
->interim_entry
, &prev_opinfo
->interim_list
);
1255 err
= oplock_break(prev_opinfo
, SMB2_OPLOCK_LEVEL_II
);
1256 opinfo_conn_put(prev_opinfo
);
1259 /* Check all oplock was freed by close */
1263 op_break_not_needed
:
1264 if (share_ret
< 0) {
1269 if (req_op_level
!= SMB2_OPLOCK_LEVEL_NONE
)
1270 req_op_level
= SMB2_OPLOCK_LEVEL_II
;
1272 /* grant fixed oplock on stacked locking between lease and oplock */
1273 if (prev_op_has_lease
&& !lctx
)
1274 if (prev_op_state
& SMB2_LEASE_HANDLE_CACHING_LE
)
1275 req_op_level
= SMB2_OPLOCK_LEVEL_NONE
;
1277 if (!prev_op_has_lease
&& lctx
) {
1278 req_op_level
= SMB2_OPLOCK_LEVEL_II
;
1279 lctx
->req_state
= SMB2_LEASE_READ_CACHING_LE
;
1283 set_oplock_level(opinfo
, req_op_level
, lctx
);
1286 rcu_assign_pointer(fp
->f_opinfo
, opinfo
);
1289 opinfo_count_inc(fp
);
1291 if (opinfo
->is_lease
) {
1292 err
= add_lease_global_list(opinfo
);
1299 free_opinfo(opinfo
);
1304 * smb_break_all_write_oplock() - break batch/exclusive oplock to level2
1306 * @fp: ksmbd file pointer
1307 * @is_trunc: truncate on open
1309 static void smb_break_all_write_oplock(struct ksmbd_work
*work
,
1310 struct ksmbd_file
*fp
, int is_trunc
)
1312 struct oplock_info
*brk_opinfo
;
1314 brk_opinfo
= opinfo_get_list(fp
->f_ci
);
1317 if (brk_opinfo
->level
!= SMB2_OPLOCK_LEVEL_BATCH
&&
1318 brk_opinfo
->level
!= SMB2_OPLOCK_LEVEL_EXCLUSIVE
) {
1319 opinfo_conn_put(brk_opinfo
);
1323 brk_opinfo
->open_trunc
= is_trunc
;
1324 list_add(&work
->interim_entry
, &brk_opinfo
->interim_list
);
1325 oplock_break(brk_opinfo
, SMB2_OPLOCK_LEVEL_II
);
1326 opinfo_conn_put(brk_opinfo
);
1330 * smb_break_all_levII_oplock() - send level2 oplock or read lease break command
1331 * from server to client
1333 * @fp: ksmbd file pointer
1334 * @is_trunc: truncate on open
1336 void smb_break_all_levII_oplock(struct ksmbd_work
*work
, struct ksmbd_file
*fp
,
1339 struct oplock_info
*op
, *brk_op
;
1340 struct ksmbd_inode
*ci
;
1341 struct ksmbd_conn
*conn
= work
->conn
;
1343 if (!test_share_config_flag(work
->tcon
->share_conf
,
1344 KSMBD_SHARE_FLAG_OPLOCKS
))
1348 op
= opinfo_get(fp
);
1351 list_for_each_entry_rcu(brk_op
, &ci
->m_op_list
, op_entry
) {
1352 if (!atomic_inc_not_zero(&brk_op
->refcount
))
1355 atomic_inc(&brk_op
->conn
->r_count
);
1356 if (ksmbd_conn_releasing(brk_op
->conn
)) {
1357 atomic_dec(&brk_op
->conn
->r_count
);
1362 if (brk_op
->is_lease
&& (brk_op
->o_lease
->state
&
1363 (~(SMB2_LEASE_READ_CACHING_LE
|
1364 SMB2_LEASE_HANDLE_CACHING_LE
)))) {
1365 ksmbd_debug(OPLOCK
, "unexpected lease state(0x%x)\n",
1366 brk_op
->o_lease
->state
);
1368 } else if (brk_op
->level
!=
1369 SMB2_OPLOCK_LEVEL_II
) {
1370 ksmbd_debug(OPLOCK
, "unexpected oplock(0x%x)\n",
1375 /* Skip oplock being break to none */
1376 if (brk_op
->is_lease
&&
1377 brk_op
->o_lease
->new_state
== SMB2_LEASE_NONE_LE
&&
1378 atomic_read(&brk_op
->breaking_cnt
))
1381 if (op
&& op
->is_lease
&& brk_op
->is_lease
&&
1382 !memcmp(conn
->ClientGUID
, brk_op
->conn
->ClientGUID
,
1383 SMB2_CLIENT_GUID_SIZE
) &&
1384 !memcmp(op
->o_lease
->lease_key
, brk_op
->o_lease
->lease_key
,
1385 SMB2_LEASE_KEY_SIZE
))
1387 brk_op
->open_trunc
= is_trunc
;
1388 oplock_break(brk_op
, SMB2_OPLOCK_LEVEL_NONE
);
1390 opinfo_conn_put(brk_op
);
1400 * smb_break_all_oplock() - break both batch/exclusive and level2 oplock
1402 * @fp: ksmbd file pointer
1404 void smb_break_all_oplock(struct ksmbd_work
*work
, struct ksmbd_file
*fp
)
1406 if (!test_share_config_flag(work
->tcon
->share_conf
,
1407 KSMBD_SHARE_FLAG_OPLOCKS
))
1410 smb_break_all_write_oplock(work
, fp
, 1);
1411 smb_break_all_levII_oplock(work
, fp
, 1);
1415 * smb2_map_lease_to_oplock() - map lease state to corresponding oplock type
1416 * @lease_state: lease type
1418 * Return: 0 if no mapping, otherwise corresponding oplock type
1420 __u8
smb2_map_lease_to_oplock(__le32 lease_state
)
1422 if (lease_state
== (SMB2_LEASE_HANDLE_CACHING_LE
|
1423 SMB2_LEASE_READ_CACHING_LE
|
1424 SMB2_LEASE_WRITE_CACHING_LE
)) {
1425 return SMB2_OPLOCK_LEVEL_BATCH
;
1426 } else if (lease_state
!= SMB2_LEASE_WRITE_CACHING_LE
&&
1427 lease_state
& SMB2_LEASE_WRITE_CACHING_LE
) {
1428 if (!(lease_state
& SMB2_LEASE_HANDLE_CACHING_LE
))
1429 return SMB2_OPLOCK_LEVEL_EXCLUSIVE
;
1430 } else if (lease_state
& SMB2_LEASE_READ_CACHING_LE
) {
1431 return SMB2_OPLOCK_LEVEL_II
;
1437 * create_lease_buf() - create lease context for open cmd response
1438 * @rbuf: buffer to create lease context response
1439 * @lease: buffer to stored parsed lease state information
1441 void create_lease_buf(u8
*rbuf
, struct lease
*lease
)
1443 if (lease
->version
== 2) {
1444 struct create_lease_v2
*buf
= (struct create_lease_v2
*)rbuf
;
1446 memset(buf
, 0, sizeof(struct create_lease_v2
));
1447 memcpy(buf
->lcontext
.LeaseKey
, lease
->lease_key
,
1448 SMB2_LEASE_KEY_SIZE
);
1449 buf
->lcontext
.LeaseFlags
= lease
->flags
;
1450 buf
->lcontext
.Epoch
= cpu_to_le16(++lease
->epoch
);
1451 buf
->lcontext
.LeaseState
= lease
->state
;
1452 memcpy(buf
->lcontext
.ParentLeaseKey
, lease
->parent_lease_key
,
1453 SMB2_LEASE_KEY_SIZE
);
1454 buf
->ccontext
.DataOffset
= cpu_to_le16(offsetof
1455 (struct create_lease_v2
, lcontext
));
1456 buf
->ccontext
.DataLength
= cpu_to_le32(sizeof(struct lease_context_v2
));
1457 buf
->ccontext
.NameOffset
= cpu_to_le16(offsetof
1458 (struct create_lease_v2
, Name
));
1459 buf
->ccontext
.NameLength
= cpu_to_le16(4);
1465 struct create_lease
*buf
= (struct create_lease
*)rbuf
;
1467 memset(buf
, 0, sizeof(struct create_lease
));
1468 memcpy(buf
->lcontext
.LeaseKey
, lease
->lease_key
, SMB2_LEASE_KEY_SIZE
);
1469 buf
->lcontext
.LeaseFlags
= lease
->flags
;
1470 buf
->lcontext
.LeaseState
= lease
->state
;
1471 buf
->ccontext
.DataOffset
= cpu_to_le16(offsetof
1472 (struct create_lease
, lcontext
));
1473 buf
->ccontext
.DataLength
= cpu_to_le32(sizeof(struct lease_context
));
1474 buf
->ccontext
.NameOffset
= cpu_to_le16(offsetof
1475 (struct create_lease
, Name
));
1476 buf
->ccontext
.NameLength
= cpu_to_le16(4);
1485 * parse_lease_state() - parse lease context containted in file open request
1486 * @open_req: buffer containing smb2 file open(create) request
1487 * @is_dir: whether leasing file is directory
1489 * Return: oplock state, -ENOENT if create lease context not found
1491 struct lease_ctx_info
*parse_lease_state(void *open_req
, bool is_dir
)
1493 struct create_context
*cc
;
1494 struct smb2_create_req
*req
= (struct smb2_create_req
*)open_req
;
1495 struct lease_ctx_info
*lreq
;
1497 cc
= smb2_find_context_vals(req
, SMB2_CREATE_REQUEST_LEASE
, 4);
1498 if (IS_ERR_OR_NULL(cc
))
1501 lreq
= kzalloc(sizeof(struct lease_ctx_info
), GFP_KERNEL
);
1505 if (sizeof(struct lease_context_v2
) == le32_to_cpu(cc
->DataLength
)) {
1506 struct create_lease_v2
*lc
= (struct create_lease_v2
*)cc
;
1508 memcpy(lreq
->lease_key
, lc
->lcontext
.LeaseKey
, SMB2_LEASE_KEY_SIZE
);
1510 lreq
->req_state
= lc
->lcontext
.LeaseState
&
1511 ~SMB2_LEASE_WRITE_CACHING_LE
;
1512 lreq
->is_dir
= true;
1514 lreq
->req_state
= lc
->lcontext
.LeaseState
;
1515 lreq
->flags
= lc
->lcontext
.LeaseFlags
;
1516 lreq
->epoch
= lc
->lcontext
.Epoch
;
1517 lreq
->duration
= lc
->lcontext
.LeaseDuration
;
1518 memcpy(lreq
->parent_lease_key
, lc
->lcontext
.ParentLeaseKey
,
1519 SMB2_LEASE_KEY_SIZE
);
1522 struct create_lease
*lc
= (struct create_lease
*)cc
;
1524 memcpy(lreq
->lease_key
, lc
->lcontext
.LeaseKey
, SMB2_LEASE_KEY_SIZE
);
1525 lreq
->req_state
= lc
->lcontext
.LeaseState
;
1526 lreq
->flags
= lc
->lcontext
.LeaseFlags
;
1527 lreq
->duration
= lc
->lcontext
.LeaseDuration
;
1534 * smb2_find_context_vals() - find a particular context info in open request
1535 * @open_req: buffer containing smb2 file open(create) request
1536 * @tag: context name to search for
1537 * @tag_len: the length of tag
1539 * Return: pointer to requested context, NULL if @str context not found
1540 * or error pointer if name length is invalid.
1542 struct create_context
*smb2_find_context_vals(void *open_req
, const char *tag
, int tag_len
)
1544 struct create_context
*cc
;
1545 unsigned int next
= 0;
1547 struct smb2_create_req
*req
= (struct smb2_create_req
*)open_req
;
1548 unsigned int remain_len
, name_off
, name_len
, value_off
, value_len
,
1552 * CreateContextsOffset and CreateContextsLength are guaranteed to
1553 * be valid because of ksmbd_smb2_check_message().
1555 cc
= (struct create_context
*)((char *)req
+
1556 le32_to_cpu(req
->CreateContextsOffset
));
1557 remain_len
= le32_to_cpu(req
->CreateContextsLength
);
1559 cc
= (struct create_context
*)((char *)cc
+ next
);
1560 if (remain_len
< offsetof(struct create_context
, Buffer
))
1561 return ERR_PTR(-EINVAL
);
1563 next
= le32_to_cpu(cc
->Next
);
1564 name_off
= le16_to_cpu(cc
->NameOffset
);
1565 name_len
= le16_to_cpu(cc
->NameLength
);
1566 value_off
= le16_to_cpu(cc
->DataOffset
);
1567 value_len
= le32_to_cpu(cc
->DataLength
);
1568 cc_len
= next
? next
: remain_len
;
1570 if ((next
& 0x7) != 0 ||
1571 next
> remain_len
||
1572 name_off
!= offsetof(struct create_context
, Buffer
) ||
1574 name_off
+ name_len
> cc_len
||
1575 (value_off
& 0x7) != 0 ||
1576 (value_len
&& value_off
< name_off
+ (name_len
< 8 ? 8 : name_len
)) ||
1577 ((u64
)value_off
+ value_len
> cc_len
))
1578 return ERR_PTR(-EINVAL
);
1580 name
= (char *)cc
+ name_off
;
1581 if (name_len
== tag_len
&& !memcmp(name
, tag
, name_len
))
1585 } while (next
!= 0);
1591 * create_durable_rsp_buf() - create durable handle context
1592 * @cc: buffer to create durable context response
1594 void create_durable_rsp_buf(char *cc
)
1596 struct create_durable_rsp
*buf
;
1598 buf
= (struct create_durable_rsp
*)cc
;
1599 memset(buf
, 0, sizeof(struct create_durable_rsp
));
1600 buf
->ccontext
.DataOffset
= cpu_to_le16(offsetof
1601 (struct create_durable_rsp
, Data
));
1602 buf
->ccontext
.DataLength
= cpu_to_le32(8);
1603 buf
->ccontext
.NameOffset
= cpu_to_le16(offsetof
1604 (struct create_durable_rsp
, Name
));
1605 buf
->ccontext
.NameLength
= cpu_to_le16(4);
1606 /* SMB2_CREATE_DURABLE_HANDLE_RESPONSE is "DHnQ" */
1614 * create_durable_v2_rsp_buf() - create durable handle v2 context
1615 * @cc: buffer to create durable context response
1616 * @fp: ksmbd file pointer
1618 void create_durable_v2_rsp_buf(char *cc
, struct ksmbd_file
*fp
)
1620 struct create_durable_v2_rsp
*buf
;
1622 buf
= (struct create_durable_v2_rsp
*)cc
;
1623 memset(buf
, 0, sizeof(struct create_durable_rsp
));
1624 buf
->ccontext
.DataOffset
= cpu_to_le16(offsetof
1625 (struct create_durable_rsp
, Data
));
1626 buf
->ccontext
.DataLength
= cpu_to_le32(8);
1627 buf
->ccontext
.NameOffset
= cpu_to_le16(offsetof
1628 (struct create_durable_rsp
, Name
));
1629 buf
->ccontext
.NameLength
= cpu_to_le16(4);
1630 /* SMB2_CREATE_DURABLE_HANDLE_RESPONSE_V2 is "DH2Q" */
1636 buf
->Timeout
= cpu_to_le32(fp
->durable_timeout
);
1640 * create_mxac_rsp_buf() - create query maximal access context
1641 * @cc: buffer to create maximal access context response
1642 * @maximal_access: maximal access
1644 void create_mxac_rsp_buf(char *cc
, int maximal_access
)
1646 struct create_mxac_rsp
*buf
;
1648 buf
= (struct create_mxac_rsp
*)cc
;
1649 memset(buf
, 0, sizeof(struct create_mxac_rsp
));
1650 buf
->ccontext
.DataOffset
= cpu_to_le16(offsetof
1651 (struct create_mxac_rsp
, QueryStatus
));
1652 buf
->ccontext
.DataLength
= cpu_to_le32(8);
1653 buf
->ccontext
.NameOffset
= cpu_to_le16(offsetof
1654 (struct create_mxac_rsp
, Name
));
1655 buf
->ccontext
.NameLength
= cpu_to_le16(4);
1656 /* SMB2_CREATE_QUERY_MAXIMAL_ACCESS_RESPONSE is "MxAc" */
1662 buf
->QueryStatus
= STATUS_SUCCESS
;
1663 buf
->MaximalAccess
= cpu_to_le32(maximal_access
);
1666 void create_disk_id_rsp_buf(char *cc
, __u64 file_id
, __u64 vol_id
)
1668 struct create_disk_id_rsp
*buf
;
1670 buf
= (struct create_disk_id_rsp
*)cc
;
1671 memset(buf
, 0, sizeof(struct create_disk_id_rsp
));
1672 buf
->ccontext
.DataOffset
= cpu_to_le16(offsetof
1673 (struct create_disk_id_rsp
, DiskFileId
));
1674 buf
->ccontext
.DataLength
= cpu_to_le32(32);
1675 buf
->ccontext
.NameOffset
= cpu_to_le16(offsetof
1676 (struct create_mxac_rsp
, Name
));
1677 buf
->ccontext
.NameLength
= cpu_to_le16(4);
1678 /* SMB2_CREATE_QUERY_ON_DISK_ID_RESPONSE is "QFid" */
1684 buf
->DiskFileId
= cpu_to_le64(file_id
);
1685 buf
->VolumeId
= cpu_to_le64(vol_id
);
1689 * create_posix_rsp_buf() - create posix extension context
1690 * @cc: buffer to create posix on posix response
1691 * @fp: ksmbd file pointer
1693 void create_posix_rsp_buf(char *cc
, struct ksmbd_file
*fp
)
1695 struct create_posix_rsp
*buf
;
1696 struct inode
*inode
= file_inode(fp
->filp
);
1697 struct mnt_idmap
*idmap
= file_mnt_idmap(fp
->filp
);
1698 vfsuid_t vfsuid
= i_uid_into_vfsuid(idmap
, inode
);
1699 vfsgid_t vfsgid
= i_gid_into_vfsgid(idmap
, inode
);
1701 buf
= (struct create_posix_rsp
*)cc
;
1702 memset(buf
, 0, sizeof(struct create_posix_rsp
));
1703 buf
->ccontext
.DataOffset
= cpu_to_le16(offsetof
1704 (struct create_posix_rsp
, nlink
));
1706 * DataLength = nlink(4) + reparse_tag(4) + mode(4) +
1707 * domain sid(28) + unix group sid(16).
1709 buf
->ccontext
.DataLength
= cpu_to_le32(56);
1710 buf
->ccontext
.NameOffset
= cpu_to_le16(offsetof
1711 (struct create_posix_rsp
, Name
));
1712 buf
->ccontext
.NameLength
= cpu_to_le16(POSIX_CTXT_DATA_LEN
);
1713 /* SMB2_CREATE_TAG_POSIX is "0x93AD25509CB411E7B42383DE968BCD7C" */
1714 buf
->Name
[0] = 0x93;
1715 buf
->Name
[1] = 0xAD;
1716 buf
->Name
[2] = 0x25;
1717 buf
->Name
[3] = 0x50;
1718 buf
->Name
[4] = 0x9C;
1719 buf
->Name
[5] = 0xB4;
1720 buf
->Name
[6] = 0x11;
1721 buf
->Name
[7] = 0xE7;
1722 buf
->Name
[8] = 0xB4;
1723 buf
->Name
[9] = 0x23;
1724 buf
->Name
[10] = 0x83;
1725 buf
->Name
[11] = 0xDE;
1726 buf
->Name
[12] = 0x96;
1727 buf
->Name
[13] = 0x8B;
1728 buf
->Name
[14] = 0xCD;
1729 buf
->Name
[15] = 0x7C;
1731 buf
->nlink
= cpu_to_le32(inode
->i_nlink
);
1732 buf
->reparse_tag
= cpu_to_le32(fp
->volatile_id
);
1733 buf
->mode
= cpu_to_le32(inode
->i_mode
& 0777);
1735 * SidBuffer(44) contain two sids(Domain sid(28), UNIX group sid(16)).
1736 * Domain sid(28) = revision(1) + num_subauth(1) + authority(6) +
1737 * sub_auth(4 * 4(num_subauth)) + RID(4).
1738 * UNIX group id(16) = revision(1) + num_subauth(1) + authority(6) +
1739 * sub_auth(4 * 1(num_subauth)) + RID(4).
1741 id_to_sid(from_kuid_munged(&init_user_ns
, vfsuid_into_kuid(vfsuid
)),
1742 SIDOWNER
, (struct smb_sid
*)&buf
->SidBuffer
[0]);
1743 id_to_sid(from_kgid_munged(&init_user_ns
, vfsgid_into_kgid(vfsgid
)),
1744 SIDUNIX_GROUP
, (struct smb_sid
*)&buf
->SidBuffer
[28]);
1748 * Find lease object(opinfo) for given lease key/fid from lease
1749 * break/file close path.
1752 * lookup_lease_in_table() - find a matching lease info object
1753 * @conn: connection instance
1754 * @lease_key: lease key to be searched for
1756 * Return: opinfo if found matching opinfo, otherwise NULL
1758 struct oplock_info
*lookup_lease_in_table(struct ksmbd_conn
*conn
,
1761 struct oplock_info
*opinfo
= NULL
, *ret_op
= NULL
;
1762 struct lease_table
*lt
;
1765 read_lock(&lease_list_lock
);
1766 list_for_each_entry(lt
, &lease_table_list
, l_entry
) {
1767 if (!memcmp(lt
->client_guid
, conn
->ClientGUID
,
1768 SMB2_CLIENT_GUID_SIZE
))
1772 read_unlock(&lease_list_lock
);
1777 list_for_each_entry_rcu(opinfo
, <
->lease_list
, lease_entry
) {
1778 if (!atomic_inc_not_zero(&opinfo
->refcount
))
1781 if (!opinfo
->op_state
|| opinfo
->op_state
== OPLOCK_CLOSING
)
1783 if (!(opinfo
->o_lease
->state
&
1784 (SMB2_LEASE_HANDLE_CACHING_LE
|
1785 SMB2_LEASE_WRITE_CACHING_LE
)))
1787 ret
= compare_guid_key(opinfo
, conn
->ClientGUID
,
1790 ksmbd_debug(OPLOCK
, "found opinfo\n");
1801 read_unlock(&lease_list_lock
);