fs/smb/server/oplock.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *   Copyright (C) 2016 Namjae Jeon <linkinjeon@kernel.org>
   4  *   Copyright (C) 2018 Samsung Electronics Co., Ltd.
   5  */
   6
   7 #include <linux/moduleparam.h>
   8
   9 #include "glob.h"
  10 #include "oplock.h"
  11
  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"
  18
  19 static LIST_HEAD(lease_table_list);
  20 static DEFINE_RWLOCK(lease_list_lock);
  21
  22 /**
  23  * alloc_opinfo() - allocate a new opinfo object for oplock info
  24  * @work:       smb work
  25  * @id:         fid of open file
  26  * @Tid:        tree id of connection
  27  *
  28  * Return:      allocated opinfo object on success, otherwise NULL
  29  */
  30 static struct oplock_info *alloc_opinfo(struct ksmbd_work *work,
  31                                         u64 id, __u16 Tid)
  32 {
  33         struct ksmbd_conn *conn = work->conn;
  34         struct ksmbd_session *sess = work->sess;
  35         struct oplock_info *opinfo;
  36
  37         opinfo = kzalloc(sizeof(struct oplock_info), GFP_KERNEL);
  38         if (!opinfo)
  39                 return NULL;
  40
  41         opinfo->sess = sess;
  42         opinfo->conn = conn;
  43         opinfo->level = SMB2_OPLOCK_LEVEL_NONE;
  44         opinfo->op_state = OPLOCK_STATE_NONE;
  45         opinfo->pending_break = 0;
  46         opinfo->fid = id;
  47         opinfo->Tid = Tid;
  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);
  54
  55         return opinfo;
  56 }
  57
  58 static void lease_add_list(struct oplock_info *opinfo)
  59 {
  60         struct lease_table *lb = opinfo->o_lease->l_lb;
  61
  62         spin_lock(&lb->lb_lock);
  63         list_add_rcu(&opinfo->lease_entry, &lb->lease_list);
  64         spin_unlock(&lb->lb_lock);
  65 }
  66
  67 static void lease_del_list(struct oplock_info *opinfo)
  68 {
  69         struct lease_table *lb = opinfo->o_lease->l_lb;
  70
  71         if (!lb)
  72                 return;
  73
  74         spin_lock(&lb->lb_lock);
  75         if (list_empty(&opinfo->lease_entry)) {
  76                 spin_unlock(&lb->lb_lock);
  77                 return;
  78         }
  79
  80         list_del_init(&opinfo->lease_entry);
  81         opinfo->o_lease->l_lb = NULL;
  82         spin_unlock(&lb->lb_lock);
  83 }
  84
  85 static void lb_add(struct lease_table *lb)
  86 {
  87         write_lock(&lease_list_lock);
  88         list_add(&lb->l_entry, &lease_table_list);
  89         write_unlock(&lease_list_lock);
  90 }
  91
  92 static int alloc_lease(struct oplock_info *opinfo, struct lease_ctx_info *lctx)
  93 {
  94         struct lease *lease;
  95
  96         lease = kmalloc(sizeof(struct lease), GFP_KERNEL);
  97         if (!lease)
  98                 return -ENOMEM;
  99
 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         memcpy(lease->parent_lease_key, lctx->parent_lease_key, SMB2_LEASE_KEY_SIZE);
 106         lease->version = lctx->version;
 107         lease->epoch = 0;
 108         INIT_LIST_HEAD(&opinfo->lease_entry);
 109         opinfo->o_lease = lease;
 110
 111         return 0;
 112 }
 113
 114 static void free_lease(struct oplock_info *opinfo)
 115 {
 116         struct lease *lease;
 117
 118         lease = opinfo->o_lease;
 119         kfree(lease);
 120 }
 121
 122 static void free_opinfo(struct oplock_info *opinfo)
 123 {
 124         if (opinfo->is_lease)
 125                 free_lease(opinfo);
 126         kfree(opinfo);
 127 }
 128
 129 static inline void opinfo_free_rcu(struct rcu_head *rcu_head)
 130 {
 131         struct oplock_info *opinfo;
 132
 133         opinfo = container_of(rcu_head, struct oplock_info, rcu_head);
 134         free_opinfo(opinfo);
 135 }
 136
 137 struct oplock_info *opinfo_get(struct ksmbd_file *fp)
 138 {
 139         struct oplock_info *opinfo;
 140
 141         rcu_read_lock();
 142         opinfo = rcu_dereference(fp->f_opinfo);
 143         if (opinfo && !atomic_inc_not_zero(&opinfo->refcount))
 144                 opinfo = NULL;
 145         rcu_read_unlock();
 146
 147         return opinfo;
 148 }
 149
 150 static struct oplock_info *opinfo_get_list(struct ksmbd_inode *ci)
 151 {
 152         struct oplock_info *opinfo;
 153
 154         if (list_empty(&ci->m_op_list))
 155                 return NULL;
 156
 157         rcu_read_lock();
 158         opinfo = list_first_or_null_rcu(&ci->m_op_list, struct oplock_info,
 159                                         op_entry);
 160         if (opinfo) {
 161                 if (!atomic_inc_not_zero(&opinfo->refcount))
 162                         opinfo = NULL;
 163                 else {
 164                         atomic_inc(&opinfo->conn->r_count);
 165                         if (ksmbd_conn_releasing(opinfo->conn)) {
 166                                 atomic_dec(&opinfo->conn->r_count);
 167                                 atomic_dec(&opinfo->refcount);
 168                                 opinfo = NULL;
 169                         }
 170                 }
 171         }
 172
 173         rcu_read_unlock();
 174
 175         return opinfo;
 176 }
 177
 178 static void opinfo_conn_put(struct oplock_info *opinfo)
 179 {
 180         struct ksmbd_conn *conn;
 181
 182         if (!opinfo)
 183                 return;
 184
 185         conn = opinfo->conn;
 186         /*
 187          * Checking waitqueue to dropping pending requests on
 188          * disconnection. waitqueue_active is safe because it
 189          * uses atomic operation for condition.
 190          */
 191         if (!atomic_dec_return(&conn->r_count) && waitqueue_active(&conn->r_count_q))
 192                 wake_up(&conn->r_count_q);
 193         opinfo_put(opinfo);
 194 }
 195
 196 void opinfo_put(struct oplock_info *opinfo)
 197 {
 198         if (!atomic_dec_and_test(&opinfo->refcount))
 199                 return;
 200
 201         call_rcu(&opinfo->rcu_head, opinfo_free_rcu);
 202 }
 203
 204 static void opinfo_add(struct oplock_info *opinfo)
 205 {
 206         struct ksmbd_inode *ci = opinfo->o_fp->f_ci;
 207
 208         write_lock(&ci->m_lock);
 209         list_add_rcu(&opinfo->op_entry, &ci->m_op_list);
 210         write_unlock(&ci->m_lock);
 211 }
 212
 213 static void opinfo_del(struct oplock_info *opinfo)
 214 {
 215         struct ksmbd_inode *ci = opinfo->o_fp->f_ci;
 216
 217         if (opinfo->is_lease) {
 218                 write_lock(&lease_list_lock);
 219                 lease_del_list(opinfo);
 220                 write_unlock(&lease_list_lock);
 221         }
 222         write_lock(&ci->m_lock);
 223         list_del_rcu(&opinfo->op_entry);
 224         write_unlock(&ci->m_lock);
 225 }
 226
 227 static unsigned long opinfo_count(struct ksmbd_file *fp)
 228 {
 229         if (ksmbd_stream_fd(fp))
 230                 return atomic_read(&fp->f_ci->sop_count);
 231         else
 232                 return atomic_read(&fp->f_ci->op_count);
 233 }
 234
 235 static void opinfo_count_inc(struct ksmbd_file *fp)
 236 {
 237         if (ksmbd_stream_fd(fp))
 238                 return atomic_inc(&fp->f_ci->sop_count);
 239         else
 240                 return atomic_inc(&fp->f_ci->op_count);
 241 }
 242
 243 static void opinfo_count_dec(struct ksmbd_file *fp)
 244 {
 245         if (ksmbd_stream_fd(fp))
 246                 return atomic_dec(&fp->f_ci->sop_count);
 247         else
 248                 return atomic_dec(&fp->f_ci->op_count);
 249 }
 250
 251 /**
 252  * opinfo_write_to_read() - convert a write oplock to read oplock
 253  * @opinfo:             current oplock info
 254  *
 255  * Return:      0 on success, otherwise -EINVAL
 256  */
 257 int opinfo_write_to_read(struct oplock_info *opinfo)
 258 {
 259         struct lease *lease = opinfo->o_lease;
 260
 261         if (!(opinfo->level == SMB2_OPLOCK_LEVEL_BATCH ||
 262               opinfo->level == SMB2_OPLOCK_LEVEL_EXCLUSIVE)) {
 263                 pr_err("bad oplock(0x%x)\n", opinfo->level);
 264                 if (opinfo->is_lease)
 265                         pr_err("lease state(0x%x)\n", lease->state);
 266                 return -EINVAL;
 267         }
 268         opinfo->level = SMB2_OPLOCK_LEVEL_II;
 269
 270         if (opinfo->is_lease)
 271                 lease->state = lease->new_state;
 272         return 0;
 273 }
 274
 275 /**
 276  * opinfo_read_handle_to_read() - convert a read/handle oplock to read oplock
 277  * @opinfo:             current oplock info
 278  *
 279  * Return:      0 on success, otherwise -EINVAL
 280  */
 281 int opinfo_read_handle_to_read(struct oplock_info *opinfo)
 282 {
 283         struct lease *lease = opinfo->o_lease;
 284
 285         lease->state = lease->new_state;
 286         opinfo->level = SMB2_OPLOCK_LEVEL_II;
 287         return 0;
 288 }
 289
 290 /**
 291  * opinfo_write_to_none() - convert a write oplock to none
 292  * @opinfo:     current oplock info
 293  *
 294  * Return:      0 on success, otherwise -EINVAL
 295  */
 296 int opinfo_write_to_none(struct oplock_info *opinfo)
 297 {
 298         struct lease *lease = opinfo->o_lease;
 299
 300         if (!(opinfo->level == SMB2_OPLOCK_LEVEL_BATCH ||
 301               opinfo->level == SMB2_OPLOCK_LEVEL_EXCLUSIVE)) {
 302                 pr_err("bad oplock(0x%x)\n", opinfo->level);
 303                 if (opinfo->is_lease)
 304                         pr_err("lease state(0x%x)\n", lease->state);
 305                 return -EINVAL;
 306         }
 307         opinfo->level = SMB2_OPLOCK_LEVEL_NONE;
 308         if (opinfo->is_lease)
 309                 lease->state = lease->new_state;
 310         return 0;
 311 }
 312
 313 /**
 314  * opinfo_read_to_none() - convert a write read to none
 315  * @opinfo:     current oplock info
 316  *
 317  * Return:      0 on success, otherwise -EINVAL
 318  */
 319 int opinfo_read_to_none(struct oplock_info *opinfo)
 320 {
 321         struct lease *lease = opinfo->o_lease;
 322
 323         if (opinfo->level != SMB2_OPLOCK_LEVEL_II) {
 324                 pr_err("bad oplock(0x%x)\n", opinfo->level);
 325                 if (opinfo->is_lease)
 326                         pr_err("lease state(0x%x)\n", lease->state);
 327                 return -EINVAL;
 328         }
 329         opinfo->level = SMB2_OPLOCK_LEVEL_NONE;
 330         if (opinfo->is_lease)
 331                 lease->state = lease->new_state;
 332         return 0;
 333 }
 334
 335 /**
 336  * lease_read_to_write() - upgrade lease state from read to write
 337  * @opinfo:     current lease info
 338  *
 339  * Return:      0 on success, otherwise -EINVAL
 340  */
 341 int lease_read_to_write(struct oplock_info *opinfo)
 342 {
 343         struct lease *lease = opinfo->o_lease;
 344
 345         if (!(lease->state & SMB2_LEASE_READ_CACHING_LE)) {
 346                 ksmbd_debug(OPLOCK, "bad lease state(0x%x)\n", lease->state);
 347                 return -EINVAL;
 348         }
 349
 350         lease->new_state = SMB2_LEASE_NONE_LE;
 351         lease->state |= SMB2_LEASE_WRITE_CACHING_LE;
 352         if (lease->state & SMB2_LEASE_HANDLE_CACHING_LE)
 353                 opinfo->level = SMB2_OPLOCK_LEVEL_BATCH;
 354         else
 355                 opinfo->level = SMB2_OPLOCK_LEVEL_EXCLUSIVE;
 356         return 0;
 357 }
 358
 359 /**
 360  * lease_none_upgrade() - upgrade lease state from none
 361  * @opinfo:     current lease info
 362  * @new_state:  new lease state
 363  *
 364  * Return:      0 on success, otherwise -EINVAL
 365  */
 366 static int lease_none_upgrade(struct oplock_info *opinfo, __le32 new_state)
 367 {
 368         struct lease *lease = opinfo->o_lease;
 369
 370         if (!(lease->state == SMB2_LEASE_NONE_LE)) {
 371                 ksmbd_debug(OPLOCK, "bad lease state(0x%x)\n", lease->state);
 372                 return -EINVAL;
 373         }
 374
 375         lease->new_state = SMB2_LEASE_NONE_LE;
 376         lease->state = new_state;
 377         if (lease->state & SMB2_LEASE_HANDLE_CACHING_LE)
 378                 if (lease->state & SMB2_LEASE_WRITE_CACHING_LE)
 379                         opinfo->level = SMB2_OPLOCK_LEVEL_BATCH;
 380                 else
 381                         opinfo->level = SMB2_OPLOCK_LEVEL_II;
 382         else if (lease->state & SMB2_LEASE_WRITE_CACHING_LE)
 383                 opinfo->level = SMB2_OPLOCK_LEVEL_EXCLUSIVE;
 384         else if (lease->state & SMB2_LEASE_READ_CACHING_LE)
 385                 opinfo->level = SMB2_OPLOCK_LEVEL_II;
 386
 387         return 0;
 388 }
 389
 390 /**
 391  * close_id_del_oplock() - release oplock object at file close time
 392  * @fp:         ksmbd file pointer
 393  */
 394 void close_id_del_oplock(struct ksmbd_file *fp)
 395 {
 396         struct oplock_info *opinfo;
 397
 398         if (S_ISDIR(file_inode(fp->filp)->i_mode))
 399                 return;
 400
 401         opinfo = opinfo_get(fp);
 402         if (!opinfo)
 403                 return;
 404
 405         opinfo_del(opinfo);
 406
 407         rcu_assign_pointer(fp->f_opinfo, NULL);
 408         if (opinfo->op_state == OPLOCK_ACK_WAIT) {
 409                 opinfo->op_state = OPLOCK_CLOSING;
 410                 wake_up_interruptible_all(&opinfo->oplock_q);
 411                 if (opinfo->is_lease) {
 412                         atomic_set(&opinfo->breaking_cnt, 0);
 413                         wake_up_interruptible_all(&opinfo->oplock_brk);
 414                 }
 415         }
 416
 417         opinfo_count_dec(fp);
 418         atomic_dec(&opinfo->refcount);
 419         opinfo_put(opinfo);
 420 }
 421
 422 /**
 423  * grant_write_oplock() - grant exclusive/batch oplock or write lease
 424  * @opinfo_new: new oplock info object
 425  * @req_oplock: request oplock
 426  * @lctx:       lease context information
 427  *
 428  * Return:      0
 429  */
 430 static void grant_write_oplock(struct oplock_info *opinfo_new, int req_oplock,
 431                                struct lease_ctx_info *lctx)
 432 {
 433         struct lease *lease = opinfo_new->o_lease;
 434
 435         if (req_oplock == SMB2_OPLOCK_LEVEL_BATCH)
 436                 opinfo_new->level = SMB2_OPLOCK_LEVEL_BATCH;
 437         else
 438                 opinfo_new->level = SMB2_OPLOCK_LEVEL_EXCLUSIVE;
 439
 440         if (lctx) {
 441                 lease->state = lctx->req_state;
 442                 memcpy(lease->lease_key, lctx->lease_key, SMB2_LEASE_KEY_SIZE);
 443         }
 444 }
 445
 446 /**
 447  * grant_read_oplock() - grant level2 oplock or read lease
 448  * @opinfo_new: new oplock info object
 449  * @lctx:       lease context information
 450  *
 451  * Return:      0
 452  */
 453 static void grant_read_oplock(struct oplock_info *opinfo_new,
 454                               struct lease_ctx_info *lctx)
 455 {
 456         struct lease *lease = opinfo_new->o_lease;
 457
 458         opinfo_new->level = SMB2_OPLOCK_LEVEL_II;
 459
 460         if (lctx) {
 461                 lease->state = SMB2_LEASE_READ_CACHING_LE;
 462                 if (lctx->req_state & SMB2_LEASE_HANDLE_CACHING_LE)
 463                         lease->state |= SMB2_LEASE_HANDLE_CACHING_LE;
 464                 memcpy(lease->lease_key, lctx->lease_key, SMB2_LEASE_KEY_SIZE);
 465         }
 466 }
 467
 468 /**
 469  * grant_none_oplock() - grant none oplock or none lease
 470  * @opinfo_new: new oplock info object
 471  * @lctx:       lease context information
 472  *
 473  * Return:      0
 474  */
 475 static void grant_none_oplock(struct oplock_info *opinfo_new,
 476                               struct lease_ctx_info *lctx)
 477 {
 478         struct lease *lease = opinfo_new->o_lease;
 479
 480         opinfo_new->level = SMB2_OPLOCK_LEVEL_NONE;
 481
 482         if (lctx) {
 483                 lease->state = 0;
 484                 memcpy(lease->lease_key, lctx->lease_key, SMB2_LEASE_KEY_SIZE);
 485         }
 486 }
 487
 488 static inline int compare_guid_key(struct oplock_info *opinfo,
 489                                    const char *guid1, const char *key1)
 490 {
 491         const char *guid2, *key2;
 492
 493         guid2 = opinfo->conn->ClientGUID;
 494         key2 = opinfo->o_lease->lease_key;
 495         if (!memcmp(guid1, guid2, SMB2_CLIENT_GUID_SIZE) &&
 496             !memcmp(key1, key2, SMB2_LEASE_KEY_SIZE))
 497                 return 1;
 498
 499         return 0;
 500 }
 501
 502 /**
 503  * same_client_has_lease() - check whether current lease request is
 504  *              from lease owner of file
 505  * @ci:         master file pointer
 506  * @client_guid:        Client GUID
 507  * @lctx:               lease context information
 508  *
 509  * Return:      oplock(lease) object on success, otherwise NULL
 510  */
 511 static struct oplock_info *same_client_has_lease(struct ksmbd_inode *ci,
 512                                                  char *client_guid,
 513                                                  struct lease_ctx_info *lctx)
 514 {
 515         int ret;
 516         struct lease *lease;
 517         struct oplock_info *opinfo;
 518         struct oplock_info *m_opinfo = NULL;
 519
 520         if (!lctx)
 521                 return NULL;
 522
 523         /*
 524          * Compare lease key and client_guid to know request from same owner
 525          * of same client
 526          */
 527         read_lock(&ci->m_lock);
 528         list_for_each_entry(opinfo, &ci->m_op_list, op_entry) {
 529                 if (!opinfo->is_lease)
 530                         continue;
 531                 read_unlock(&ci->m_lock);
 532                 lease = opinfo->o_lease;
 533
 534                 ret = compare_guid_key(opinfo, client_guid, lctx->lease_key);
 535                 if (ret) {
 536                         m_opinfo = opinfo;
 537                         /* skip upgrading lease about breaking lease */
 538                         if (atomic_read(&opinfo->breaking_cnt)) {
 539                                 read_lock(&ci->m_lock);
 540                                 continue;
 541                         }
 542
 543                         /* upgrading lease */
 544                         if ((atomic_read(&ci->op_count) +
 545                              atomic_read(&ci->sop_count)) == 1) {
 546                                 if (lease->state ==
 547                                     (lctx->req_state & lease->state)) {
 548                                         lease->state |= lctx->req_state;
 549                                         if (lctx->req_state &
 550                                                 SMB2_LEASE_WRITE_CACHING_LE)
 551                                                 lease_read_to_write(opinfo);
 552                                 }
 553                         } else if ((atomic_read(&ci->op_count) +
 554                                     atomic_read(&ci->sop_count)) > 1) {
 555                                 if (lctx->req_state ==
 556                                     (SMB2_LEASE_READ_CACHING_LE |
 557                                      SMB2_LEASE_HANDLE_CACHING_LE))
 558                                         lease->state = lctx->req_state;
 559                         }
 560
 561                         if (lctx->req_state && lease->state ==
 562                             SMB2_LEASE_NONE_LE)
 563                                 lease_none_upgrade(opinfo, lctx->req_state);
 564                 }
 565                 read_lock(&ci->m_lock);
 566         }
 567         read_unlock(&ci->m_lock);
 568
 569         return m_opinfo;
 570 }
 571
 572 static void wait_for_break_ack(struct oplock_info *opinfo)
 573 {
 574         int rc = 0;
 575
 576         rc = wait_event_interruptible_timeout(opinfo->oplock_q,
 577                                               opinfo->op_state == OPLOCK_STATE_NONE ||
 578                                               opinfo->op_state == OPLOCK_CLOSING,
 579                                               OPLOCK_WAIT_TIME);
 580
 581         /* is this a timeout ? */
 582         if (!rc) {
 583                 if (opinfo->is_lease)
 584                         opinfo->o_lease->state = SMB2_LEASE_NONE_LE;
 585                 opinfo->level = SMB2_OPLOCK_LEVEL_NONE;
 586                 opinfo->op_state = OPLOCK_STATE_NONE;
 587         }
 588 }
 589
 590 static void wake_up_oplock_break(struct oplock_info *opinfo)
 591 {
 592         clear_bit_unlock(0, &opinfo->pending_break);
 593         /* memory barrier is needed for wake_up_bit() */
 594         smp_mb__after_atomic();
 595         wake_up_bit(&opinfo->pending_break, 0);
 596 }
 597
 598 static int oplock_break_pending(struct oplock_info *opinfo, int req_op_level)
 599 {
 600         while (test_and_set_bit(0, &opinfo->pending_break)) {
 601                 wait_on_bit(&opinfo->pending_break, 0, TASK_UNINTERRUPTIBLE);
 602
 603                 /* Not immediately break to none. */
 604                 opinfo->open_trunc = 0;
 605
 606                 if (opinfo->op_state == OPLOCK_CLOSING)
 607                         return -ENOENT;
 608                 else if (!opinfo->is_lease && opinfo->level <= req_op_level)
 609                         return 1;
 610         }
 611
 612         if (!opinfo->is_lease && opinfo->level <= req_op_level) {
 613                 wake_up_oplock_break(opinfo);
 614                 return 1;
 615         }
 616         return 0;
 617 }
 618
 619 /**
 620  * __smb2_oplock_break_noti() - send smb2 oplock break cmd from conn
 621  * to client
 622  * @wk:     smb work object
 623  *
 624  * There are two ways this function can be called. 1- while file open we break
 625  * from exclusive/batch lock to levelII oplock and 2- while file write/truncate
 626  * we break from levelII oplock no oplock.
 627  * work->request_buf contains oplock_info.
 628  */
 629 static void __smb2_oplock_break_noti(struct work_struct *wk)
 630 {
 631         struct smb2_oplock_break *rsp = NULL;
 632         struct ksmbd_work *work = container_of(wk, struct ksmbd_work, work);
 633         struct oplock_break_info *br_info = work->request_buf;
 634         struct smb2_hdr *rsp_hdr;
 635         struct ksmbd_file *fp;
 636
 637         fp = ksmbd_lookup_durable_fd(br_info->fid);
 638         if (!fp)
 639                 goto out;
 640
 641         if (allocate_interim_rsp_buf(work)) {
 642                 pr_err("smb2_allocate_rsp_buf failed! ");
 643                 ksmbd_fd_put(work, fp);
 644                 goto out;
 645         }
 646
 647         rsp_hdr = smb2_get_msg(work->response_buf);
 648         memset(rsp_hdr, 0, sizeof(struct smb2_hdr) + 2);
 649         rsp_hdr->ProtocolId = SMB2_PROTO_NUMBER;
 650         rsp_hdr->StructureSize = SMB2_HEADER_STRUCTURE_SIZE;
 651         rsp_hdr->CreditRequest = cpu_to_le16(0);
 652         rsp_hdr->Command = SMB2_OPLOCK_BREAK;
 653         rsp_hdr->Flags = (SMB2_FLAGS_SERVER_TO_REDIR);
 654         rsp_hdr->NextCommand = 0;
 655         rsp_hdr->MessageId = cpu_to_le64(-1);
 656         rsp_hdr->Id.SyncId.ProcessId = 0;
 657         rsp_hdr->Id.SyncId.TreeId = 0;
 658         rsp_hdr->SessionId = 0;
 659         memset(rsp_hdr->Signature, 0, 16);
 660
 661         rsp = smb2_get_msg(work->response_buf);
 662
 663         rsp->StructureSize = cpu_to_le16(24);
 664         if (!br_info->open_trunc &&
 665             (br_info->level == SMB2_OPLOCK_LEVEL_BATCH ||
 666              br_info->level == SMB2_OPLOCK_LEVEL_EXCLUSIVE))
 667                 rsp->OplockLevel = SMB2_OPLOCK_LEVEL_II;
 668         else
 669                 rsp->OplockLevel = SMB2_OPLOCK_LEVEL_NONE;
 670         rsp->Reserved = 0;
 671         rsp->Reserved2 = 0;
 672         rsp->PersistentFid = fp->persistent_id;
 673         rsp->VolatileFid = fp->volatile_id;
 674
 675         ksmbd_fd_put(work, fp);
 676         if (ksmbd_iov_pin_rsp(work, (void *)rsp,
 677                               sizeof(struct smb2_oplock_break)))
 678                 goto out;
 679
 680         ksmbd_debug(OPLOCK,
 681                     "sending oplock break v_id %llu p_id = %llu lock level = %d\n",
 682                     rsp->VolatileFid, rsp->PersistentFid, rsp->OplockLevel);
 683
 684         ksmbd_conn_write(work);
 685
 686 out:
 687         ksmbd_free_work_struct(work);
 688 }
 689
 690 /**
 691  * smb2_oplock_break_noti() - send smb2 exclusive/batch to level2 oplock
 692  *              break command from server to client
 693  * @opinfo:             oplock info object
 694  *
 695  * Return:      0 on success, otherwise error
 696  */
 697 static int smb2_oplock_break_noti(struct oplock_info *opinfo)
 698 {
 699         struct ksmbd_conn *conn = opinfo->conn;
 700         struct oplock_break_info *br_info;
 701         int ret = 0;
 702         struct ksmbd_work *work = ksmbd_alloc_work_struct();
 703
 704         if (!work)
 705                 return -ENOMEM;
 706
 707         br_info = kmalloc(sizeof(struct oplock_break_info), GFP_KERNEL);
 708         if (!br_info) {
 709                 ksmbd_free_work_struct(work);
 710                 return -ENOMEM;
 711         }
 712
 713         br_info->level = opinfo->level;
 714         br_info->fid = opinfo->fid;
 715         br_info->open_trunc = opinfo->open_trunc;
 716
 717         work->request_buf = (char *)br_info;
 718         work->conn = conn;
 719         work->sess = opinfo->sess;
 720
 721         if (opinfo->op_state == OPLOCK_ACK_WAIT) {
 722                 INIT_WORK(&work->work, __smb2_oplock_break_noti);
 723                 ksmbd_queue_work(work);
 724
 725                 wait_for_break_ack(opinfo);
 726         } else {
 727                 __smb2_oplock_break_noti(&work->work);
 728                 if (opinfo->level == SMB2_OPLOCK_LEVEL_II)
 729                         opinfo->level = SMB2_OPLOCK_LEVEL_NONE;
 730         }
 731         return ret;
 732 }
 733
 734 /**
 735  * __smb2_lease_break_noti() - send lease break command from server
 736  * to client
 737  * @wk:     smb work object
 738  */
 739 static void __smb2_lease_break_noti(struct work_struct *wk)
 740 {
 741         struct smb2_lease_break *rsp = NULL;
 742         struct ksmbd_work *work = container_of(wk, struct ksmbd_work, work);
 743         struct lease_break_info *br_info = work->request_buf;
 744         struct smb2_hdr *rsp_hdr;
 745
 746         if (allocate_interim_rsp_buf(work)) {
 747                 ksmbd_debug(OPLOCK, "smb2_allocate_rsp_buf failed! ");
 748                 goto out;
 749         }
 750
 751         rsp_hdr = smb2_get_msg(work->response_buf);
 752         memset(rsp_hdr, 0, sizeof(struct smb2_hdr) + 2);
 753         rsp_hdr->ProtocolId = SMB2_PROTO_NUMBER;
 754         rsp_hdr->StructureSize = SMB2_HEADER_STRUCTURE_SIZE;
 755         rsp_hdr->CreditRequest = cpu_to_le16(0);
 756         rsp_hdr->Command = SMB2_OPLOCK_BREAK;
 757         rsp_hdr->Flags = (SMB2_FLAGS_SERVER_TO_REDIR);
 758         rsp_hdr->NextCommand = 0;
 759         rsp_hdr->MessageId = cpu_to_le64(-1);
 760         rsp_hdr->Id.SyncId.ProcessId = 0;
 761         rsp_hdr->Id.SyncId.TreeId = 0;
 762         rsp_hdr->SessionId = 0;
 763         memset(rsp_hdr->Signature, 0, 16);
 764
 765         rsp = smb2_get_msg(work->response_buf);
 766         rsp->StructureSize = cpu_to_le16(44);
 767         rsp->Epoch = br_info->epoch;
 768         rsp->Flags = 0;
 769
 770         if (br_info->curr_state & (SMB2_LEASE_WRITE_CACHING_LE |
 771                         SMB2_LEASE_HANDLE_CACHING_LE))
 772                 rsp->Flags = SMB2_NOTIFY_BREAK_LEASE_FLAG_ACK_REQUIRED;
 773
 774         memcpy(rsp->LeaseKey, br_info->lease_key, SMB2_LEASE_KEY_SIZE);
 775         rsp->CurrentLeaseState = br_info->curr_state;
 776         rsp->NewLeaseState = br_info->new_state;
 777         rsp->BreakReason = 0;
 778         rsp->AccessMaskHint = 0;
 779         rsp->ShareMaskHint = 0;
 780
 781         if (ksmbd_iov_pin_rsp(work, (void *)rsp,
 782                               sizeof(struct smb2_lease_break)))
 783                 goto out;
 784
 785         ksmbd_conn_write(work);
 786
 787 out:
 788         ksmbd_free_work_struct(work);
 789 }
 790
 791 /**
 792  * smb2_lease_break_noti() - break lease when a new client request
 793  *                      write lease
 794  * @opinfo:             conains lease state information
 795  *
 796  * Return:      0 on success, otherwise error
 797  */
 798 static int smb2_lease_break_noti(struct oplock_info *opinfo)
 799 {
 800         struct ksmbd_conn *conn = opinfo->conn;
 801         struct list_head *tmp, *t;
 802         struct ksmbd_work *work;
 803         struct lease_break_info *br_info;
 804         struct lease *lease = opinfo->o_lease;
 805
 806         work = ksmbd_alloc_work_struct();
 807         if (!work)
 808                 return -ENOMEM;
 809
 810         br_info = kmalloc(sizeof(struct lease_break_info), GFP_KERNEL);
 811         if (!br_info) {
 812                 ksmbd_free_work_struct(work);
 813                 return -ENOMEM;
 814         }
 815
 816         br_info->curr_state = lease->state;
 817         br_info->new_state = lease->new_state;
 818         if (lease->version == 2)
 819                 br_info->epoch = cpu_to_le16(++lease->epoch);
 820         else
 821                 br_info->epoch = 0;
 822         memcpy(br_info->lease_key, lease->lease_key, SMB2_LEASE_KEY_SIZE);
 823
 824         work->request_buf = (char *)br_info;
 825         work->conn = conn;
 826         work->sess = opinfo->sess;
 827
 828         if (opinfo->op_state == OPLOCK_ACK_WAIT) {
 829                 list_for_each_safe(tmp, t, &opinfo->interim_list) {
 830                         struct ksmbd_work *in_work;
 831
 832                         in_work = list_entry(tmp, struct ksmbd_work,
 833                                              interim_entry);
 834                         setup_async_work(in_work, NULL, NULL);
 835                         smb2_send_interim_resp(in_work, STATUS_PENDING);
 836                         list_del_init(&in_work->interim_entry);
 837                         release_async_work(in_work);
 838                 }
 839                 INIT_WORK(&work->work, __smb2_lease_break_noti);
 840                 ksmbd_queue_work(work);
 841                 wait_for_break_ack(opinfo);
 842         } else {
 843                 __smb2_lease_break_noti(&work->work);
 844                 if (opinfo->o_lease->new_state == SMB2_LEASE_NONE_LE) {
 845                         opinfo->level = SMB2_OPLOCK_LEVEL_NONE;
 846                         opinfo->o_lease->state = SMB2_LEASE_NONE_LE;
 847                 }
 848         }
 849         return 0;
 850 }
 851
 852 static void wait_lease_breaking(struct oplock_info *opinfo)
 853 {
 854         if (!opinfo->is_lease)
 855                 return;
 856
 857         wake_up_interruptible_all(&opinfo->oplock_brk);
 858         if (atomic_read(&opinfo->breaking_cnt)) {
 859                 int ret = 0;
 860
 861                 ret = wait_event_interruptible_timeout(opinfo->oplock_brk,
 862                                                        atomic_read(&opinfo->breaking_cnt) == 0,
 863                                                        HZ);
 864                 if (!ret)
 865                         atomic_set(&opinfo->breaking_cnt, 0);
 866         }
 867 }
 868
 869 static int oplock_break(struct oplock_info *brk_opinfo, int req_op_level)
 870 {
 871         int err = 0;
 872
 873         /* Need to break exclusive/batch oplock, write lease or overwrite_if */
 874         ksmbd_debug(OPLOCK,
 875                     "request to send oplock(level : 0x%x) break notification\n",
 876                     brk_opinfo->level);
 877
 878         if (brk_opinfo->is_lease) {
 879                 struct lease *lease = brk_opinfo->o_lease;
 880
 881                 atomic_inc(&brk_opinfo->breaking_cnt);
 882
 883                 err = oplock_break_pending(brk_opinfo, req_op_level);
 884                 if (err)
 885                         return err < 0 ? err : 0;
 886
 887                 if (brk_opinfo->open_trunc) {
 888                         /*
 889                          * Create overwrite break trigger the lease break to
 890                          * none.
 891                          */
 892                         lease->new_state = SMB2_LEASE_NONE_LE;
 893                 } else {
 894                         if (lease->state & SMB2_LEASE_WRITE_CACHING_LE) {
 895                                 if (lease->state & SMB2_LEASE_HANDLE_CACHING_LE)
 896                                         lease->new_state =
 897                                                 SMB2_LEASE_READ_CACHING_LE |
 898                                                 SMB2_LEASE_HANDLE_CACHING_LE;
 899                                 else
 900                                         lease->new_state =
 901                                                 SMB2_LEASE_READ_CACHING_LE;
 902                         } else {
 903                                 if (lease->state & SMB2_LEASE_HANDLE_CACHING_LE)
 904                                         lease->new_state =
 905                                                 SMB2_LEASE_READ_CACHING_LE;
 906                                 else
 907                                         lease->new_state = SMB2_LEASE_NONE_LE;
 908                         }
 909                 }
 910
 911                 if (lease->state & (SMB2_LEASE_WRITE_CACHING_LE |
 912                                 SMB2_LEASE_HANDLE_CACHING_LE))
 913                         brk_opinfo->op_state = OPLOCK_ACK_WAIT;
 914                 else
 915                         atomic_dec(&brk_opinfo->breaking_cnt);
 916         } else {
 917                 err = oplock_break_pending(brk_opinfo, req_op_level);
 918                 if (err)
 919                         return err < 0 ? err : 0;
 920
 921                 if (brk_opinfo->level == SMB2_OPLOCK_LEVEL_BATCH ||
 922                     brk_opinfo->level == SMB2_OPLOCK_LEVEL_EXCLUSIVE)
 923                         brk_opinfo->op_state = OPLOCK_ACK_WAIT;
 924         }
 925
 926         if (brk_opinfo->is_lease)
 927                 err = smb2_lease_break_noti(brk_opinfo);
 928         else
 929                 err = smb2_oplock_break_noti(brk_opinfo);
 930
 931         ksmbd_debug(OPLOCK, "oplock granted = %d\n", brk_opinfo->level);
 932         if (brk_opinfo->op_state == OPLOCK_CLOSING)
 933                 err = -ENOENT;
 934         wake_up_oplock_break(brk_opinfo);
 935
 936         wait_lease_breaking(brk_opinfo);
 937
 938         return err;
 939 }
 940
 941 void destroy_lease_table(struct ksmbd_conn *conn)
 942 {
 943         struct lease_table *lb, *lbtmp;
 944         struct oplock_info *opinfo;
 945
 946         write_lock(&lease_list_lock);
 947         if (list_empty(&lease_table_list)) {
 948                 write_unlock(&lease_list_lock);
 949                 return;
 950         }
 951
 952         list_for_each_entry_safe(lb, lbtmp, &lease_table_list, l_entry) {
 953                 if (conn && memcmp(lb->client_guid, conn->ClientGUID,
 954                                    SMB2_CLIENT_GUID_SIZE))
 955                         continue;
 956 again:
 957                 rcu_read_lock();
 958                 list_for_each_entry_rcu(opinfo, &lb->lease_list,
 959                                         lease_entry) {
 960                         rcu_read_unlock();
 961                         lease_del_list(opinfo);
 962                         goto again;
 963                 }
 964                 rcu_read_unlock();
 965                 list_del(&lb->l_entry);
 966                 kfree(lb);
 967         }
 968         write_unlock(&lease_list_lock);
 969 }
 970
 971 int find_same_lease_key(struct ksmbd_session *sess, struct ksmbd_inode *ci,
 972                         struct lease_ctx_info *lctx)
 973 {
 974         struct oplock_info *opinfo;
 975         int err = 0;
 976         struct lease_table *lb;
 977
 978         if (!lctx)
 979                 return err;
 980
 981         read_lock(&lease_list_lock);
 982         if (list_empty(&lease_table_list)) {
 983                 read_unlock(&lease_list_lock);
 984                 return 0;
 985         }
 986
 987         list_for_each_entry(lb, &lease_table_list, l_entry) {
 988                 if (!memcmp(lb->client_guid, sess->ClientGUID,
 989                             SMB2_CLIENT_GUID_SIZE))
 990                         goto found;
 991         }
 992         read_unlock(&lease_list_lock);
 993
 994         return 0;
 995
 996 found:
 997         rcu_read_lock();
 998         list_for_each_entry_rcu(opinfo, &lb->lease_list, lease_entry) {
 999                 if (!atomic_inc_not_zero(&opinfo->refcount))
1000                         continue;
1001                 rcu_read_unlock();
1002                 if (opinfo->o_fp->f_ci == ci)
1003                         goto op_next;
1004                 err = compare_guid_key(opinfo, sess->ClientGUID,
1005                                        lctx->lease_key);
1006                 if (err) {
1007                         err = -EINVAL;
1008                         ksmbd_debug(OPLOCK,
1009                                     "found same lease key is already used in other files\n");
1010                         opinfo_put(opinfo);
1011                         goto out;
1012                 }
1013 op_next:
1014                 opinfo_put(opinfo);
1015                 rcu_read_lock();
1016         }
1017         rcu_read_unlock();
1018
1019 out:
1020         read_unlock(&lease_list_lock);
1021         return err;
1022 }
1023
1024 static void copy_lease(struct oplock_info *op1, struct oplock_info *op2)
1025 {
1026         struct lease *lease1 = op1->o_lease;
1027         struct lease *lease2 = op2->o_lease;
1028
1029         op2->level = op1->level;
1030         lease2->state = lease1->state;
1031         memcpy(lease2->lease_key, lease1->lease_key,
1032                SMB2_LEASE_KEY_SIZE);
1033         lease2->duration = lease1->duration;
1034         lease2->flags = lease1->flags;
1035 }
1036
1037 static int add_lease_global_list(struct oplock_info *opinfo)
1038 {
1039         struct lease_table *lb;
1040
1041         read_lock(&lease_list_lock);
1042         list_for_each_entry(lb, &lease_table_list, l_entry) {
1043                 if (!memcmp(lb->client_guid, opinfo->conn->ClientGUID,
1044                             SMB2_CLIENT_GUID_SIZE)) {
1045                         opinfo->o_lease->l_lb = lb;
1046                         lease_add_list(opinfo);
1047                         read_unlock(&lease_list_lock);
1048                         return 0;
1049                 }
1050         }
1051         read_unlock(&lease_list_lock);
1052
1053         lb = kmalloc(sizeof(struct lease_table), GFP_KERNEL);
1054         if (!lb)
1055                 return -ENOMEM;
1056
1057         memcpy(lb->client_guid, opinfo->conn->ClientGUID,
1058                SMB2_CLIENT_GUID_SIZE);
1059         INIT_LIST_HEAD(&lb->lease_list);
1060         spin_lock_init(&lb->lb_lock);
1061         opinfo->o_lease->l_lb = lb;
1062         lease_add_list(opinfo);
1063         lb_add(lb);
1064         return 0;
1065 }
1066
1067 static void set_oplock_level(struct oplock_info *opinfo, int level,
1068                              struct lease_ctx_info *lctx)
1069 {
1070         switch (level) {
1071         case SMB2_OPLOCK_LEVEL_BATCH:
1072         case SMB2_OPLOCK_LEVEL_EXCLUSIVE:
1073                 grant_write_oplock(opinfo, level, lctx);
1074                 break;
1075         case SMB2_OPLOCK_LEVEL_II:
1076                 grant_read_oplock(opinfo, lctx);
1077                 break;
1078         default:
1079                 grant_none_oplock(opinfo, lctx);
1080                 break;
1081         }
1082 }
1083
1084 /**
1085  * smb_grant_oplock() - handle oplock/lease request on file open
1086  * @work:               smb work
1087  * @req_op_level:       oplock level
1088  * @pid:                id of open file
1089  * @fp:                 ksmbd file pointer
1090  * @tid:                Tree id of connection
1091  * @lctx:               lease context information on file open
1092  * @share_ret:          share mode
1093  *
1094  * Return:      0 on success, otherwise error
1095  */
1096 int smb_grant_oplock(struct ksmbd_work *work, int req_op_level, u64 pid,
1097                      struct ksmbd_file *fp, __u16 tid,
1098                      struct lease_ctx_info *lctx, int share_ret)
1099 {
1100         struct ksmbd_session *sess = work->sess;
1101         int err = 0;
1102         struct oplock_info *opinfo = NULL, *prev_opinfo = NULL;
1103         struct ksmbd_inode *ci = fp->f_ci;
1104         bool prev_op_has_lease;
1105         __le32 prev_op_state = 0;
1106
1107         /* not support directory lease */
1108         if (S_ISDIR(file_inode(fp->filp)->i_mode))
1109                 return 0;
1110
1111         opinfo = alloc_opinfo(work, pid, tid);
1112         if (!opinfo)
1113                 return -ENOMEM;
1114
1115         if (lctx) {
1116                 err = alloc_lease(opinfo, lctx);
1117                 if (err)
1118                         goto err_out;
1119                 opinfo->is_lease = 1;
1120         }
1121
1122         /* ci does not have any oplock */
1123         if (!opinfo_count(fp))
1124                 goto set_lev;
1125
1126         /* grant none-oplock if second open is trunc */
1127         if (fp->attrib_only && fp->cdoption != FILE_OVERWRITE_IF_LE &&
1128             fp->cdoption != FILE_OVERWRITE_LE &&
1129             fp->cdoption != FILE_SUPERSEDE_LE) {
1130                 req_op_level = SMB2_OPLOCK_LEVEL_NONE;
1131                 goto set_lev;
1132         }
1133
1134         if (lctx) {
1135                 struct oplock_info *m_opinfo;
1136
1137                 /* is lease already granted ? */
1138                 m_opinfo = same_client_has_lease(ci, sess->ClientGUID,
1139                                                  lctx);
1140                 if (m_opinfo) {
1141                         copy_lease(m_opinfo, opinfo);
1142                         if (atomic_read(&m_opinfo->breaking_cnt))
1143                                 opinfo->o_lease->flags =
1144                                         SMB2_LEASE_FLAG_BREAK_IN_PROGRESS_LE;
1145                         goto out;
1146                 }
1147         }
1148         prev_opinfo = opinfo_get_list(ci);
1149         if (!prev_opinfo ||
1150             (prev_opinfo->level == SMB2_OPLOCK_LEVEL_NONE && lctx)) {
1151                 opinfo_conn_put(prev_opinfo);
1152                 goto set_lev;
1153         }
1154         prev_op_has_lease = prev_opinfo->is_lease;
1155         if (prev_op_has_lease)
1156                 prev_op_state = prev_opinfo->o_lease->state;
1157
1158         if (share_ret < 0 &&
1159             prev_opinfo->level == SMB2_OPLOCK_LEVEL_EXCLUSIVE) {
1160                 err = share_ret;
1161                 opinfo_conn_put(prev_opinfo);
1162                 goto err_out;
1163         }
1164
1165         if (prev_opinfo->level != SMB2_OPLOCK_LEVEL_BATCH &&
1166             prev_opinfo->level != SMB2_OPLOCK_LEVEL_EXCLUSIVE) {
1167                 opinfo_conn_put(prev_opinfo);
1168                 goto op_break_not_needed;
1169         }
1170
1171         list_add(&work->interim_entry, &prev_opinfo->interim_list);
1172         err = oplock_break(prev_opinfo, SMB2_OPLOCK_LEVEL_II);
1173         opinfo_conn_put(prev_opinfo);
1174         if (err == -ENOENT)
1175                 goto set_lev;
1176         /* Check all oplock was freed by close */
1177         else if (err < 0)
1178                 goto err_out;
1179
1180 op_break_not_needed:
1181         if (share_ret < 0) {
1182                 err = share_ret;
1183                 goto err_out;
1184         }
1185
1186         if (req_op_level != SMB2_OPLOCK_LEVEL_NONE)
1187                 req_op_level = SMB2_OPLOCK_LEVEL_II;
1188
1189         /* grant fixed oplock on stacked locking between lease and oplock */
1190         if (prev_op_has_lease && !lctx)
1191                 if (prev_op_state & SMB2_LEASE_HANDLE_CACHING_LE)
1192                         req_op_level = SMB2_OPLOCK_LEVEL_NONE;
1193
1194         if (!prev_op_has_lease && lctx) {
1195                 req_op_level = SMB2_OPLOCK_LEVEL_II;
1196                 lctx->req_state = SMB2_LEASE_READ_CACHING_LE;
1197         }
1198
1199 set_lev:
1200         set_oplock_level(opinfo, req_op_level, lctx);
1201
1202 out:
1203         rcu_assign_pointer(fp->f_opinfo, opinfo);
1204         opinfo->o_fp = fp;
1205
1206         opinfo_count_inc(fp);
1207         opinfo_add(opinfo);
1208         if (opinfo->is_lease) {
1209                 err = add_lease_global_list(opinfo);
1210                 if (err)
1211                         goto err_out;
1212         }
1213
1214         return 0;
1215 err_out:
1216         free_opinfo(opinfo);
1217         return err;
1218 }
1219
1220 /**
1221  * smb_break_all_write_oplock() - break batch/exclusive oplock to level2
1222  * @work:       smb work
1223  * @fp:         ksmbd file pointer
1224  * @is_trunc:   truncate on open
1225  */
1226 static void smb_break_all_write_oplock(struct ksmbd_work *work,
1227                                        struct ksmbd_file *fp, int is_trunc)
1228 {
1229         struct oplock_info *brk_opinfo;
1230
1231         brk_opinfo = opinfo_get_list(fp->f_ci);
1232         if (!brk_opinfo)
1233                 return;
1234         if (brk_opinfo->level != SMB2_OPLOCK_LEVEL_BATCH &&
1235             brk_opinfo->level != SMB2_OPLOCK_LEVEL_EXCLUSIVE) {
1236                 opinfo_conn_put(brk_opinfo);
1237                 return;
1238         }
1239
1240         brk_opinfo->open_trunc = is_trunc;
1241         list_add(&work->interim_entry, &brk_opinfo->interim_list);
1242         oplock_break(brk_opinfo, SMB2_OPLOCK_LEVEL_II);
1243         opinfo_conn_put(brk_opinfo);
1244 }
1245
1246 /**
1247  * smb_break_all_levII_oplock() - send level2 oplock or read lease break command
1248  *      from server to client
1249  * @work:       smb work
1250  * @fp:         ksmbd file pointer
1251  * @is_trunc:   truncate on open
1252  */
1253 void smb_break_all_levII_oplock(struct ksmbd_work *work, struct ksmbd_file *fp,
1254                                 int is_trunc)
1255 {
1256         struct oplock_info *op, *brk_op;
1257         struct ksmbd_inode *ci;
1258         struct ksmbd_conn *conn = work->conn;
1259
1260         if (!test_share_config_flag(work->tcon->share_conf,
1261                                     KSMBD_SHARE_FLAG_OPLOCKS))
1262                 return;
1263
1264         ci = fp->f_ci;
1265         op = opinfo_get(fp);
1266
1267         rcu_read_lock();
1268         list_for_each_entry_rcu(brk_op, &ci->m_op_list, op_entry) {
1269                 if (!atomic_inc_not_zero(&brk_op->refcount))
1270                         continue;
1271
1272                 atomic_inc(&brk_op->conn->r_count);
1273                 if (ksmbd_conn_releasing(brk_op->conn)) {
1274                         atomic_dec(&brk_op->conn->r_count);
1275                         continue;
1276                 }
1277
1278                 rcu_read_unlock();
1279                 if (brk_op->is_lease && (brk_op->o_lease->state &
1280                     (~(SMB2_LEASE_READ_CACHING_LE |
1281                                 SMB2_LEASE_HANDLE_CACHING_LE)))) {
1282                         ksmbd_debug(OPLOCK, "unexpected lease state(0x%x)\n",
1283                                     brk_op->o_lease->state);
1284                         goto next;
1285                 } else if (brk_op->level !=
1286                                 SMB2_OPLOCK_LEVEL_II) {
1287                         ksmbd_debug(OPLOCK, "unexpected oplock(0x%x)\n",
1288                                     brk_op->level);
1289                         goto next;
1290                 }
1291
1292                 /* Skip oplock being break to none */
1293                 if (brk_op->is_lease &&
1294                     brk_op->o_lease->new_state == SMB2_LEASE_NONE_LE &&
1295                     atomic_read(&brk_op->breaking_cnt))
1296                         goto next;
1297
1298                 if (op && op->is_lease && brk_op->is_lease &&
1299                     !memcmp(conn->ClientGUID, brk_op->conn->ClientGUID,
1300                             SMB2_CLIENT_GUID_SIZE) &&
1301                     !memcmp(op->o_lease->lease_key, brk_op->o_lease->lease_key,
1302                             SMB2_LEASE_KEY_SIZE))
1303                         goto next;
1304                 brk_op->open_trunc = is_trunc;
1305                 oplock_break(brk_op, SMB2_OPLOCK_LEVEL_NONE);
1306 next:
1307                 opinfo_conn_put(brk_op);
1308                 rcu_read_lock();
1309         }
1310         rcu_read_unlock();
1311
1312         if (op)
1313                 opinfo_put(op);
1314 }
1315
1316 /**
1317  * smb_break_all_oplock() - break both batch/exclusive and level2 oplock
1318  * @work:       smb work
1319  * @fp:         ksmbd file pointer
1320  */
1321 void smb_break_all_oplock(struct ksmbd_work *work, struct ksmbd_file *fp)
1322 {
1323         if (!test_share_config_flag(work->tcon->share_conf,
1324                                     KSMBD_SHARE_FLAG_OPLOCKS))
1325                 return;
1326
1327         smb_break_all_write_oplock(work, fp, 1);
1328         smb_break_all_levII_oplock(work, fp, 1);
1329 }
1330
1331 /**
1332  * smb2_map_lease_to_oplock() - map lease state to corresponding oplock type
1333  * @lease_state:     lease type
1334  *
1335  * Return:      0 if no mapping, otherwise corresponding oplock type
1336  */
1337 __u8 smb2_map_lease_to_oplock(__le32 lease_state)
1338 {
1339         if (lease_state == (SMB2_LEASE_HANDLE_CACHING_LE |
1340                             SMB2_LEASE_READ_CACHING_LE |
1341                             SMB2_LEASE_WRITE_CACHING_LE)) {
1342                 return SMB2_OPLOCK_LEVEL_BATCH;
1343         } else if (lease_state != SMB2_LEASE_WRITE_CACHING_LE &&
1344                  lease_state & SMB2_LEASE_WRITE_CACHING_LE) {
1345                 if (!(lease_state & SMB2_LEASE_HANDLE_CACHING_LE))
1346                         return SMB2_OPLOCK_LEVEL_EXCLUSIVE;
1347         } else if (lease_state & SMB2_LEASE_READ_CACHING_LE) {
1348                 return SMB2_OPLOCK_LEVEL_II;
1349         }
1350         return 0;
1351 }
1352
1353 /**
1354  * create_lease_buf() - create lease context for open cmd response
1355  * @rbuf:       buffer to create lease context response
1356  * @lease:      buffer to stored parsed lease state information
1357  */
1358 void create_lease_buf(u8 *rbuf, struct lease *lease)
1359 {
1360         if (lease->version == 2) {
1361                 struct create_lease_v2 *buf = (struct create_lease_v2 *)rbuf;
1362
1363                 memset(buf, 0, sizeof(struct create_lease_v2));
1364                 memcpy(buf->lcontext.LeaseKey, lease->lease_key,
1365                        SMB2_LEASE_KEY_SIZE);
1366                 buf->lcontext.LeaseFlags = lease->flags;
1367                 buf->lcontext.LeaseState = lease->state;
1368                 memcpy(buf->lcontext.ParentLeaseKey, lease->parent_lease_key,
1369                        SMB2_LEASE_KEY_SIZE);
1370                 buf->ccontext.DataOffset = cpu_to_le16(offsetof
1371                                 (struct create_lease_v2, lcontext));
1372                 buf->ccontext.DataLength = cpu_to_le32(sizeof(struct lease_context_v2));
1373                 buf->ccontext.NameOffset = cpu_to_le16(offsetof
1374                                 (struct create_lease_v2, Name));
1375                 buf->ccontext.NameLength = cpu_to_le16(4);
1376                 buf->Name[0] = 'R';
1377                 buf->Name[1] = 'q';
1378                 buf->Name[2] = 'L';
1379                 buf->Name[3] = 's';
1380         } else {
1381                 struct create_lease *buf = (struct create_lease *)rbuf;
1382
1383                 memset(buf, 0, sizeof(struct create_lease));
1384                 memcpy(buf->lcontext.LeaseKey, lease->lease_key, SMB2_LEASE_KEY_SIZE);
1385                 buf->lcontext.LeaseFlags = lease->flags;
1386                 buf->lcontext.LeaseState = lease->state;
1387                 buf->ccontext.DataOffset = cpu_to_le16(offsetof
1388                                 (struct create_lease, lcontext));
1389                 buf->ccontext.DataLength = cpu_to_le32(sizeof(struct lease_context));
1390                 buf->ccontext.NameOffset = cpu_to_le16(offsetof
1391                                 (struct create_lease, Name));
1392                 buf->ccontext.NameLength = cpu_to_le16(4);
1393                 buf->Name[0] = 'R';
1394                 buf->Name[1] = 'q';
1395                 buf->Name[2] = 'L';
1396                 buf->Name[3] = 's';
1397         }
1398 }
1399
1400 /**
1401  * parse_lease_state() - parse lease context containted in file open request
1402  * @open_req:   buffer containing smb2 file open(create) request
1403  *
1404  * Return:  oplock state, -ENOENT if create lease context not found
1405  */
1406 struct lease_ctx_info *parse_lease_state(void *open_req)
1407 {
1408         struct create_context *cc;
1409         struct smb2_create_req *req = (struct smb2_create_req *)open_req;
1410         struct lease_ctx_info *lreq;
1411
1412         cc = smb2_find_context_vals(req, SMB2_CREATE_REQUEST_LEASE, 4);
1413         if (IS_ERR_OR_NULL(cc))
1414                 return NULL;
1415
1416         lreq = kzalloc(sizeof(struct lease_ctx_info), GFP_KERNEL);
1417         if (!lreq)
1418                 return NULL;
1419
1420         if (sizeof(struct lease_context_v2) == le32_to_cpu(cc->DataLength)) {
1421                 struct create_lease_v2 *lc = (struct create_lease_v2 *)cc;
1422
1423                 memcpy(lreq->lease_key, lc->lcontext.LeaseKey, SMB2_LEASE_KEY_SIZE);
1424                 lreq->req_state = lc->lcontext.LeaseState;
1425                 lreq->flags = lc->lcontext.LeaseFlags;
1426                 lreq->duration = lc->lcontext.LeaseDuration;
1427                 memcpy(lreq->parent_lease_key, lc->lcontext.ParentLeaseKey,
1428                                 SMB2_LEASE_KEY_SIZE);
1429                 lreq->version = 2;
1430         } else {
1431                 struct create_lease *lc = (struct create_lease *)cc;
1432
1433                 memcpy(lreq->lease_key, lc->lcontext.LeaseKey, SMB2_LEASE_KEY_SIZE);
1434                 lreq->req_state = lc->lcontext.LeaseState;
1435                 lreq->flags = lc->lcontext.LeaseFlags;
1436                 lreq->duration = lc->lcontext.LeaseDuration;
1437                 lreq->version = 1;
1438         }
1439         return lreq;
1440 }
1441
1442 /**
1443  * smb2_find_context_vals() - find a particular context info in open request
1444  * @open_req:   buffer containing smb2 file open(create) request
1445  * @tag:        context name to search for
1446  * @tag_len:    the length of tag
1447  *
1448  * Return:      pointer to requested context, NULL if @str context not found
1449  *              or error pointer if name length is invalid.
1450  */
1451 struct create_context *smb2_find_context_vals(void *open_req, const char *tag, int tag_len)
1452 {
1453         struct create_context *cc;
1454         unsigned int next = 0;
1455         char *name;
1456         struct smb2_create_req *req = (struct smb2_create_req *)open_req;
1457         unsigned int remain_len, name_off, name_len, value_off, value_len,
1458                      cc_len;
1459
1460         /*
1461          * CreateContextsOffset and CreateContextsLength are guaranteed to
1462          * be valid because of ksmbd_smb2_check_message().
1463          */
1464         cc = (struct create_context *)((char *)req +
1465                                        le32_to_cpu(req->CreateContextsOffset));
1466         remain_len = le32_to_cpu(req->CreateContextsLength);
1467         do {
1468                 cc = (struct create_context *)((char *)cc + next);
1469                 if (remain_len < offsetof(struct create_context, Buffer))
1470                         return ERR_PTR(-EINVAL);
1471
1472                 next = le32_to_cpu(cc->Next);
1473                 name_off = le16_to_cpu(cc->NameOffset);
1474                 name_len = le16_to_cpu(cc->NameLength);
1475                 value_off = le16_to_cpu(cc->DataOffset);
1476                 value_len = le32_to_cpu(cc->DataLength);
1477                 cc_len = next ? next : remain_len;
1478
1479                 if ((next & 0x7) != 0 ||
1480                     next > remain_len ||
1481                     name_off != offsetof(struct create_context, Buffer) ||
1482                     name_len < 4 ||
1483                     name_off + name_len > cc_len ||
1484                     (value_off & 0x7) != 0 ||
1485                     (value_len && value_off < name_off + (name_len < 8 ? 8 : name_len)) ||
1486                     ((u64)value_off + value_len > cc_len))
1487                         return ERR_PTR(-EINVAL);
1488
1489                 name = (char *)cc + name_off;
1490                 if (name_len == tag_len && !memcmp(name, tag, name_len))
1491                         return cc;
1492
1493                 remain_len -= next;
1494         } while (next != 0);
1495
1496         return NULL;
1497 }
1498
1499 /**
1500  * create_durable_rsp_buf() - create durable handle context
1501  * @cc: buffer to create durable context response
1502  */
1503 void create_durable_rsp_buf(char *cc)
1504 {
1505         struct create_durable_rsp *buf;
1506
1507         buf = (struct create_durable_rsp *)cc;
1508         memset(buf, 0, sizeof(struct create_durable_rsp));
1509         buf->ccontext.DataOffset = cpu_to_le16(offsetof
1510                         (struct create_durable_rsp, Data));
1511         buf->ccontext.DataLength = cpu_to_le32(8);
1512         buf->ccontext.NameOffset = cpu_to_le16(offsetof
1513                         (struct create_durable_rsp, Name));
1514         buf->ccontext.NameLength = cpu_to_le16(4);
1515         /* SMB2_CREATE_DURABLE_HANDLE_RESPONSE is "DHnQ" */
1516         buf->Name[0] = 'D';
1517         buf->Name[1] = 'H';
1518         buf->Name[2] = 'n';
1519         buf->Name[3] = 'Q';
1520 }
1521
1522 /**
1523  * create_durable_v2_rsp_buf() - create durable handle v2 context
1524  * @cc: buffer to create durable context response
1525  * @fp: ksmbd file pointer
1526  */
1527 void create_durable_v2_rsp_buf(char *cc, struct ksmbd_file *fp)
1528 {
1529         struct create_durable_v2_rsp *buf;
1530
1531         buf = (struct create_durable_v2_rsp *)cc;
1532         memset(buf, 0, sizeof(struct create_durable_rsp));
1533         buf->ccontext.DataOffset = cpu_to_le16(offsetof
1534                         (struct create_durable_rsp, Data));
1535         buf->ccontext.DataLength = cpu_to_le32(8);
1536         buf->ccontext.NameOffset = cpu_to_le16(offsetof
1537                         (struct create_durable_rsp, Name));
1538         buf->ccontext.NameLength = cpu_to_le16(4);
1539         /* SMB2_CREATE_DURABLE_HANDLE_RESPONSE_V2 is "DH2Q" */
1540         buf->Name[0] = 'D';
1541         buf->Name[1] = 'H';
1542         buf->Name[2] = '2';
1543         buf->Name[3] = 'Q';
1544
1545         buf->Timeout = cpu_to_le32(fp->durable_timeout);
1546 }
1547
1548 /**
1549  * create_mxac_rsp_buf() - create query maximal access context
1550  * @cc:                 buffer to create maximal access context response
1551  * @maximal_access:     maximal access
1552  */
1553 void create_mxac_rsp_buf(char *cc, int maximal_access)
1554 {
1555         struct create_mxac_rsp *buf;
1556
1557         buf = (struct create_mxac_rsp *)cc;
1558         memset(buf, 0, sizeof(struct create_mxac_rsp));
1559         buf->ccontext.DataOffset = cpu_to_le16(offsetof
1560                         (struct create_mxac_rsp, QueryStatus));
1561         buf->ccontext.DataLength = cpu_to_le32(8);
1562         buf->ccontext.NameOffset = cpu_to_le16(offsetof
1563                         (struct create_mxac_rsp, Name));
1564         buf->ccontext.NameLength = cpu_to_le16(4);
1565         /* SMB2_CREATE_QUERY_MAXIMAL_ACCESS_RESPONSE is "MxAc" */
1566         buf->Name[0] = 'M';
1567         buf->Name[1] = 'x';
1568         buf->Name[2] = 'A';
1569         buf->Name[3] = 'c';
1570
1571         buf->QueryStatus = STATUS_SUCCESS;
1572         buf->MaximalAccess = cpu_to_le32(maximal_access);
1573 }
1574
1575 void create_disk_id_rsp_buf(char *cc, __u64 file_id, __u64 vol_id)
1576 {
1577         struct create_disk_id_rsp *buf;
1578
1579         buf = (struct create_disk_id_rsp *)cc;
1580         memset(buf, 0, sizeof(struct create_disk_id_rsp));
1581         buf->ccontext.DataOffset = cpu_to_le16(offsetof
1582                         (struct create_disk_id_rsp, DiskFileId));
1583         buf->ccontext.DataLength = cpu_to_le32(32);
1584         buf->ccontext.NameOffset = cpu_to_le16(offsetof
1585                         (struct create_mxac_rsp, Name));
1586         buf->ccontext.NameLength = cpu_to_le16(4);
1587         /* SMB2_CREATE_QUERY_ON_DISK_ID_RESPONSE is "QFid" */
1588         buf->Name[0] = 'Q';
1589         buf->Name[1] = 'F';
1590         buf->Name[2] = 'i';
1591         buf->Name[3] = 'd';
1592
1593         buf->DiskFileId = cpu_to_le64(file_id);
1594         buf->VolumeId = cpu_to_le64(vol_id);
1595 }
1596
1597 /**
1598  * create_posix_rsp_buf() - create posix extension context
1599  * @cc: buffer to create posix on posix response
1600  * @fp: ksmbd file pointer
1601  */
1602 void create_posix_rsp_buf(char *cc, struct ksmbd_file *fp)
1603 {
1604         struct create_posix_rsp *buf;
1605         struct inode *inode = file_inode(fp->filp);
1606         struct mnt_idmap *idmap = file_mnt_idmap(fp->filp);
1607         vfsuid_t vfsuid = i_uid_into_vfsuid(idmap, inode);
1608         vfsgid_t vfsgid = i_gid_into_vfsgid(idmap, inode);
1609
1610         buf = (struct create_posix_rsp *)cc;
1611         memset(buf, 0, sizeof(struct create_posix_rsp));
1612         buf->ccontext.DataOffset = cpu_to_le16(offsetof
1613                         (struct create_posix_rsp, nlink));
1614         /*
1615          * DataLength = nlink(4) + reparse_tag(4) + mode(4) +
1616          * domain sid(28) + unix group sid(16).
1617          */
1618         buf->ccontext.DataLength = cpu_to_le32(56);
1619         buf->ccontext.NameOffset = cpu_to_le16(offsetof
1620                         (struct create_posix_rsp, Name));
1621         buf->ccontext.NameLength = cpu_to_le16(POSIX_CTXT_DATA_LEN);
1622         /* SMB2_CREATE_TAG_POSIX is "0x93AD25509CB411E7B42383DE968BCD7C" */
1623         buf->Name[0] = 0x93;
1624         buf->Name[1] = 0xAD;
1625         buf->Name[2] = 0x25;
1626         buf->Name[3] = 0x50;
1627         buf->Name[4] = 0x9C;
1628         buf->Name[5] = 0xB4;
1629         buf->Name[6] = 0x11;
1630         buf->Name[7] = 0xE7;
1631         buf->Name[8] = 0xB4;
1632         buf->Name[9] = 0x23;
1633         buf->Name[10] = 0x83;
1634         buf->Name[11] = 0xDE;
1635         buf->Name[12] = 0x96;
1636         buf->Name[13] = 0x8B;
1637         buf->Name[14] = 0xCD;
1638         buf->Name[15] = 0x7C;
1639
1640         buf->nlink = cpu_to_le32(inode->i_nlink);
1641         buf->reparse_tag = cpu_to_le32(fp->volatile_id);
1642         buf->mode = cpu_to_le32(inode->i_mode & 0777);
1643         /*
1644          * SidBuffer(44) contain two sids(Domain sid(28), UNIX group sid(16)).
1645          * Domain sid(28) = revision(1) + num_subauth(1) + authority(6) +
1646          *                  sub_auth(4 * 4(num_subauth)) + RID(4).
1647          * UNIX group id(16) = revision(1) + num_subauth(1) + authority(6) +
1648          *                     sub_auth(4 * 1(num_subauth)) + RID(4).
1649          */
1650         id_to_sid(from_kuid_munged(&init_user_ns, vfsuid_into_kuid(vfsuid)),
1651                   SIDOWNER, (struct smb_sid *)&buf->SidBuffer[0]);
1652         id_to_sid(from_kgid_munged(&init_user_ns, vfsgid_into_kgid(vfsgid)),
1653                   SIDUNIX_GROUP, (struct smb_sid *)&buf->SidBuffer[28]);
1654 }
1655
1656 /*
1657  * Find lease object(opinfo) for given lease key/fid from lease
1658  * break/file close path.
1659  */
1660 /**
1661  * lookup_lease_in_table() - find a matching lease info object
1662  * @conn:       connection instance
1663  * @lease_key:  lease key to be searched for
1664  *
1665  * Return:      opinfo if found matching opinfo, otherwise NULL
1666  */
1667 struct oplock_info *lookup_lease_in_table(struct ksmbd_conn *conn,
1668                                           char *lease_key)
1669 {
1670         struct oplock_info *opinfo = NULL, *ret_op = NULL;
1671         struct lease_table *lt;
1672         int ret;
1673
1674         read_lock(&lease_list_lock);
1675         list_for_each_entry(lt, &lease_table_list, l_entry) {
1676                 if (!memcmp(lt->client_guid, conn->ClientGUID,
1677                             SMB2_CLIENT_GUID_SIZE))
1678                         goto found;
1679         }
1680
1681         read_unlock(&lease_list_lock);
1682         return NULL;
1683
1684 found:
1685         rcu_read_lock();
1686         list_for_each_entry_rcu(opinfo, &lt->lease_list, lease_entry) {
1687                 if (!atomic_inc_not_zero(&opinfo->refcount))
1688                         continue;
1689                 rcu_read_unlock();
1690                 if (!opinfo->op_state || opinfo->op_state == OPLOCK_CLOSING)
1691                         goto op_next;
1692                 if (!(opinfo->o_lease->state &
1693                       (SMB2_LEASE_HANDLE_CACHING_LE |
1694                        SMB2_LEASE_WRITE_CACHING_LE)))
1695                         goto op_next;
1696                 ret = compare_guid_key(opinfo, conn->ClientGUID,
1697                                        lease_key);
1698                 if (ret) {
1699                         ksmbd_debug(OPLOCK, "found opinfo\n");
1700                         ret_op = opinfo;
1701                         goto out;
1702                 }
1703 op_next:
1704                 opinfo_put(opinfo);
1705                 rcu_read_lock();
1706         }
1707         rcu_read_unlock();
1708
1709 out:
1710         read_unlock(&lease_list_lock);
1711         return ret_op;
1712 }