1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Copyright (C) 2016 Namjae Jeon <linkinjeon@kernel.org> 4 * Copyright (C) 2019 Samsung Electronics Co., Ltd. 5 */ 6 7 #include <linux/fs.h> 8 #include <linux/filelock.h> 9 #include <linux/slab.h> 10 #include <linux/vmalloc.h> 11 #include <linux/kthread.h> 12 #include <linux/freezer.h> 13 14 #include "glob.h" 15 #include "vfs_cache.h" 16 #include "oplock.h" 17 #include "vfs.h" 18 #include "connection.h" 19 #include "mgmt/tree_connect.h" 20 #include "mgmt/user_session.h" 21 #include "smb_common.h" 22 #include "server.h" 23 24 #define S_DEL_PENDING 1 25 #define S_DEL_ON_CLS 2 26 #define S_DEL_ON_CLS_STREAM 8 27 28 static unsigned int inode_hash_mask __read_mostly; 29 static unsigned int inode_hash_shift __read_mostly; 30 static struct hlist_head *inode_hashtable __read_mostly; 31 static DEFINE_RWLOCK(inode_hash_lock); 32 33 static struct ksmbd_file_table global_ft; 34 static atomic_long_t fd_limit; 35 static struct kmem_cache *filp_cache; 36 37 static bool durable_scavenger_running; 38 static DEFINE_MUTEX(durable_scavenger_lock); 39 static wait_queue_head_t dh_wq; 40 41 void ksmbd_set_fd_limit(unsigned long limit) 42 { 43 limit = min(limit, get_max_files()); 44 atomic_long_set(&fd_limit, limit); 45 } 46 47 static bool fd_limit_depleted(void) 48 { 49 long v = atomic_long_dec_return(&fd_limit); 50 51 if (v >= 0) 52 return false; 53 atomic_long_inc(&fd_limit); 54 return true; 55 } 56 57 static void fd_limit_close(void) 58 { 59 atomic_long_inc(&fd_limit); 60 } 61 62 /* 63 * INODE hash 64 */ 65 66 static unsigned long inode_hash(struct super_block *sb, unsigned long hashval) 67 { 68 unsigned long tmp; 69 70 tmp = (hashval * (unsigned long)sb) ^ (GOLDEN_RATIO_PRIME + hashval) / 71 L1_CACHE_BYTES; 72 tmp = tmp ^ ((tmp ^ GOLDEN_RATIO_PRIME) >> inode_hash_shift); 73 return tmp & inode_hash_mask; 74 } 75 76 static struct ksmbd_inode *__ksmbd_inode_lookup(struct dentry *de) 77 { 78 struct hlist_head *head = inode_hashtable + 79 inode_hash(d_inode(de)->i_sb, (unsigned long)de); 80 struct ksmbd_inode *ci = NULL, *ret_ci = NULL; 81 82 hlist_for_each_entry(ci, head, m_hash) { 83 if (ci->m_de == de) { 84 if (atomic_inc_not_zero(&ci->m_count)) 85 ret_ci = ci; 86 break; 87 } 88 } 89 return ret_ci; 90 } 91 92 static struct ksmbd_inode *ksmbd_inode_lookup(struct ksmbd_file *fp) 93 { 94 return __ksmbd_inode_lookup(fp->filp->f_path.dentry); 95 } 96 97 struct ksmbd_inode *ksmbd_inode_lookup_lock(struct dentry *d) 98 { 99 struct ksmbd_inode *ci; 100 101 read_lock(&inode_hash_lock); 102 ci = __ksmbd_inode_lookup(d); 103 read_unlock(&inode_hash_lock); 104 105 return ci; 106 } 107 108 int ksmbd_query_inode_status(struct dentry *dentry) 109 { 110 struct ksmbd_inode *ci; 111 int ret = KSMBD_INODE_STATUS_UNKNOWN; 112 113 read_lock(&inode_hash_lock); 114 ci = __ksmbd_inode_lookup(dentry); 115 read_unlock(&inode_hash_lock); 116 if (!ci) 117 return ret; 118 119 down_read(&ci->m_lock); 120 if (ci->m_flags & (S_DEL_PENDING | S_DEL_ON_CLS)) 121 ret = KSMBD_INODE_STATUS_PENDING_DELETE; 122 else 123 ret = KSMBD_INODE_STATUS_OK; 124 up_read(&ci->m_lock); 125 126 atomic_dec(&ci->m_count); 127 return ret; 128 } 129 130 bool ksmbd_inode_pending_delete(struct ksmbd_file *fp) 131 { 132 struct ksmbd_inode *ci = fp->f_ci; 133 int ret; 134 135 down_read(&ci->m_lock); 136 ret = (ci->m_flags & (S_DEL_PENDING | S_DEL_ON_CLS)); 137 up_read(&ci->m_lock); 138 139 return ret; 140 } 141 142 void ksmbd_set_inode_pending_delete(struct ksmbd_file *fp) 143 { 144 struct ksmbd_inode *ci = fp->f_ci; 145 146 down_write(&ci->m_lock); 147 ci->m_flags |= S_DEL_PENDING; 148 up_write(&ci->m_lock); 149 } 150 151 void ksmbd_clear_inode_pending_delete(struct ksmbd_file *fp) 152 { 153 struct ksmbd_inode *ci = fp->f_ci; 154 155 down_write(&ci->m_lock); 156 ci->m_flags &= ~S_DEL_PENDING; 157 up_write(&ci->m_lock); 158 } 159 160 void ksmbd_fd_set_delete_on_close(struct ksmbd_file *fp, 161 int file_info) 162 { 163 struct ksmbd_inode *ci = fp->f_ci; 164 165 down_write(&ci->m_lock); 166 if (ksmbd_stream_fd(fp)) 167 ci->m_flags |= S_DEL_ON_CLS_STREAM; 168 else 169 ci->m_flags |= S_DEL_ON_CLS; 170 up_write(&ci->m_lock); 171 } 172 173 static void ksmbd_inode_hash(struct ksmbd_inode *ci) 174 { 175 struct hlist_head *b = inode_hashtable + 176 inode_hash(d_inode(ci->m_de)->i_sb, (unsigned long)ci->m_de); 177 178 hlist_add_head(&ci->m_hash, b); 179 } 180 181 static void ksmbd_inode_unhash(struct ksmbd_inode *ci) 182 { 183 write_lock(&inode_hash_lock); 184 hlist_del_init(&ci->m_hash); 185 write_unlock(&inode_hash_lock); 186 } 187 188 static int ksmbd_inode_init(struct ksmbd_inode *ci, struct ksmbd_file *fp) 189 { 190 atomic_set(&ci->m_count, 1); 191 atomic_set(&ci->op_count, 0); 192 atomic_set(&ci->sop_count, 0); 193 ci->m_flags = 0; 194 ci->m_fattr = 0; 195 INIT_LIST_HEAD(&ci->m_fp_list); 196 INIT_LIST_HEAD(&ci->m_op_list); 197 init_rwsem(&ci->m_lock); 198 ci->m_de = fp->filp->f_path.dentry; 199 return 0; 200 } 201 202 static struct ksmbd_inode *ksmbd_inode_get(struct ksmbd_file *fp) 203 { 204 struct ksmbd_inode *ci, *tmpci; 205 int rc; 206 207 read_lock(&inode_hash_lock); 208 ci = ksmbd_inode_lookup(fp); 209 read_unlock(&inode_hash_lock); 210 if (ci) 211 return ci; 212 213 ci = kmalloc(sizeof(struct ksmbd_inode), KSMBD_DEFAULT_GFP); 214 if (!ci) 215 return NULL; 216 217 rc = ksmbd_inode_init(ci, fp); 218 if (rc) { 219 pr_err("inode initialized failed\n"); 220 kfree(ci); 221 return NULL; 222 } 223 224 write_lock(&inode_hash_lock); 225 tmpci = ksmbd_inode_lookup(fp); 226 if (!tmpci) { 227 ksmbd_inode_hash(ci); 228 } else { 229 kfree(ci); 230 ci = tmpci; 231 } 232 write_unlock(&inode_hash_lock); 233 return ci; 234 } 235 236 static void ksmbd_inode_free(struct ksmbd_inode *ci) 237 { 238 ksmbd_inode_unhash(ci); 239 kfree(ci); 240 } 241 242 void ksmbd_inode_put(struct ksmbd_inode *ci) 243 { 244 if (atomic_dec_and_test(&ci->m_count)) 245 ksmbd_inode_free(ci); 246 } 247 248 int __init ksmbd_inode_hash_init(void) 249 { 250 unsigned int loop; 251 unsigned long numentries = 16384; 252 unsigned long bucketsize = sizeof(struct hlist_head); 253 unsigned long size; 254 255 inode_hash_shift = ilog2(numentries); 256 inode_hash_mask = (1 << inode_hash_shift) - 1; 257 258 size = bucketsize << inode_hash_shift; 259 260 /* init master fp hash table */ 261 inode_hashtable = vmalloc(size); 262 if (!inode_hashtable) 263 return -ENOMEM; 264 265 for (loop = 0; loop < (1U << inode_hash_shift); loop++) 266 INIT_HLIST_HEAD(&inode_hashtable[loop]); 267 return 0; 268 } 269 270 void ksmbd_release_inode_hash(void) 271 { 272 vfree(inode_hashtable); 273 } 274 275 static void __ksmbd_inode_close(struct ksmbd_file *fp) 276 { 277 struct ksmbd_inode *ci = fp->f_ci; 278 int err; 279 struct file *filp; 280 281 filp = fp->filp; 282 283 if (ksmbd_stream_fd(fp)) { 284 bool remove_stream_xattr = false; 285 286 down_write(&ci->m_lock); 287 if (ci->m_flags & S_DEL_ON_CLS_STREAM) { 288 ci->m_flags &= ~S_DEL_ON_CLS_STREAM; 289 remove_stream_xattr = true; 290 } 291 up_write(&ci->m_lock); 292 293 if (remove_stream_xattr) { 294 err = ksmbd_vfs_remove_xattr(file_mnt_idmap(filp), 295 &filp->f_path, 296 fp->stream.name, 297 true); 298 if (err) 299 pr_err("remove xattr failed : %s\n", 300 fp->stream.name); 301 } 302 } 303 304 if (atomic_dec_and_test(&ci->m_count)) { 305 bool do_unlink = false; 306 307 down_write(&ci->m_lock); 308 if (ci->m_flags & (S_DEL_ON_CLS | S_DEL_PENDING)) { 309 ci->m_flags &= ~(S_DEL_ON_CLS | S_DEL_PENDING); 310 do_unlink = true; 311 } 312 up_write(&ci->m_lock); 313 314 if (do_unlink) 315 ksmbd_vfs_unlink(filp); 316 317 ksmbd_inode_free(ci); 318 } 319 } 320 321 static void __ksmbd_remove_durable_fd(struct ksmbd_file *fp) 322 { 323 if (!has_file_id(fp->persistent_id)) 324 return; 325 326 idr_remove(global_ft.idr, fp->persistent_id); 327 } 328 329 static void ksmbd_remove_durable_fd(struct ksmbd_file *fp) 330 { 331 write_lock(&global_ft.lock); 332 __ksmbd_remove_durable_fd(fp); 333 write_unlock(&global_ft.lock); 334 if (waitqueue_active(&dh_wq)) 335 wake_up(&dh_wq); 336 } 337 338 static void __ksmbd_remove_fd(struct ksmbd_file_table *ft, struct ksmbd_file *fp) 339 { 340 if (!has_file_id(fp->volatile_id)) 341 return; 342 343 down_write(&fp->f_ci->m_lock); 344 list_del_init(&fp->node); 345 up_write(&fp->f_ci->m_lock); 346 347 write_lock(&ft->lock); 348 idr_remove(ft->idr, fp->volatile_id); 349 write_unlock(&ft->lock); 350 } 351 352 static void __ksmbd_close_fd(struct ksmbd_file_table *ft, struct ksmbd_file *fp) 353 { 354 struct file *filp; 355 struct ksmbd_lock *smb_lock, *tmp_lock; 356 357 fd_limit_close(); 358 ksmbd_remove_durable_fd(fp); 359 if (ft) 360 __ksmbd_remove_fd(ft, fp); 361 362 close_id_del_oplock(fp); 363 filp = fp->filp; 364 365 __ksmbd_inode_close(fp); 366 if (!IS_ERR_OR_NULL(filp)) 367 fput(filp); 368 369 /* because the reference count of fp is 0, it is guaranteed that 370 * there are not accesses to fp->lock_list. 371 */ 372 list_for_each_entry_safe(smb_lock, tmp_lock, &fp->lock_list, flist) { 373 spin_lock(&fp->conn->llist_lock); 374 list_del(&smb_lock->clist); 375 spin_unlock(&fp->conn->llist_lock); 376 377 list_del(&smb_lock->flist); 378 locks_free_lock(smb_lock->fl); 379 kfree(smb_lock); 380 } 381 382 if (ksmbd_stream_fd(fp)) 383 kfree(fp->stream.name); 384 kmem_cache_free(filp_cache, fp); 385 } 386 387 static struct ksmbd_file *ksmbd_fp_get(struct ksmbd_file *fp) 388 { 389 if (fp->f_state != FP_INITED) 390 return NULL; 391 392 if (!atomic_inc_not_zero(&fp->refcount)) 393 return NULL; 394 return fp; 395 } 396 397 static struct ksmbd_file *__ksmbd_lookup_fd(struct ksmbd_file_table *ft, 398 u64 id) 399 { 400 struct ksmbd_file *fp; 401 402 if (!has_file_id(id)) 403 return NULL; 404 405 read_lock(&ft->lock); 406 fp = idr_find(ft->idr, id); 407 if (fp) 408 fp = ksmbd_fp_get(fp); 409 read_unlock(&ft->lock); 410 return fp; 411 } 412 413 static void __put_fd_final(struct ksmbd_work *work, struct ksmbd_file *fp) 414 { 415 __ksmbd_close_fd(&work->sess->file_table, fp); 416 atomic_dec(&work->conn->stats.open_files_count); 417 } 418 419 static void set_close_state_blocked_works(struct ksmbd_file *fp) 420 { 421 struct ksmbd_work *cancel_work; 422 423 spin_lock(&fp->f_lock); 424 list_for_each_entry(cancel_work, &fp->blocked_works, 425 fp_entry) { 426 cancel_work->state = KSMBD_WORK_CLOSED; 427 cancel_work->cancel_fn(cancel_work->cancel_argv); 428 } 429 spin_unlock(&fp->f_lock); 430 } 431 432 int ksmbd_close_fd(struct ksmbd_work *work, u64 id) 433 { 434 struct ksmbd_file *fp; 435 struct ksmbd_file_table *ft; 436 437 if (!has_file_id(id)) 438 return 0; 439 440 ft = &work->sess->file_table; 441 write_lock(&ft->lock); 442 fp = idr_find(ft->idr, id); 443 if (fp) { 444 set_close_state_blocked_works(fp); 445 446 if (fp->f_state != FP_INITED) 447 fp = NULL; 448 else { 449 fp->f_state = FP_CLOSED; 450 if (!atomic_dec_and_test(&fp->refcount)) 451 fp = NULL; 452 } 453 } 454 write_unlock(&ft->lock); 455 456 if (!fp) 457 return -EINVAL; 458 459 __put_fd_final(work, fp); 460 return 0; 461 } 462 463 void ksmbd_fd_put(struct ksmbd_work *work, struct ksmbd_file *fp) 464 { 465 if (!fp) 466 return; 467 468 if (!atomic_dec_and_test(&fp->refcount)) 469 return; 470 __put_fd_final(work, fp); 471 } 472 473 static bool __sanity_check(struct ksmbd_tree_connect *tcon, struct ksmbd_file *fp) 474 { 475 if (!fp) 476 return false; 477 if (fp->tcon != tcon) 478 return false; 479 return true; 480 } 481 482 struct ksmbd_file *ksmbd_lookup_foreign_fd(struct ksmbd_work *work, u64 id) 483 { 484 return __ksmbd_lookup_fd(&work->sess->file_table, id); 485 } 486 487 struct ksmbd_file *ksmbd_lookup_fd_fast(struct ksmbd_work *work, u64 id) 488 { 489 struct ksmbd_file *fp = __ksmbd_lookup_fd(&work->sess->file_table, id); 490 491 if (__sanity_check(work->tcon, fp)) 492 return fp; 493 494 ksmbd_fd_put(work, fp); 495 return NULL; 496 } 497 498 struct ksmbd_file *ksmbd_lookup_fd_slow(struct ksmbd_work *work, u64 id, 499 u64 pid) 500 { 501 struct ksmbd_file *fp; 502 503 if (!has_file_id(id)) { 504 id = work->compound_fid; 505 pid = work->compound_pfid; 506 } 507 508 fp = __ksmbd_lookup_fd(&work->sess->file_table, id); 509 if (!__sanity_check(work->tcon, fp)) { 510 ksmbd_fd_put(work, fp); 511 return NULL; 512 } 513 if (fp->persistent_id != pid) { 514 ksmbd_fd_put(work, fp); 515 return NULL; 516 } 517 return fp; 518 } 519 520 struct ksmbd_file *ksmbd_lookup_global_fd(unsigned long long id) 521 { 522 return __ksmbd_lookup_fd(&global_ft, id); 523 } 524 525 struct ksmbd_file *ksmbd_lookup_durable_fd(unsigned long long id) 526 { 527 struct ksmbd_file *fp; 528 529 fp = __ksmbd_lookup_fd(&global_ft, id); 530 if (fp && (fp->conn || 531 (fp->durable_scavenger_timeout && 532 (fp->durable_scavenger_timeout < 533 jiffies_to_msecs(jiffies))))) { 534 ksmbd_put_durable_fd(fp); 535 fp = NULL; 536 } 537 538 return fp; 539 } 540 541 void ksmbd_put_durable_fd(struct ksmbd_file *fp) 542 { 543 if (!atomic_dec_and_test(&fp->refcount)) 544 return; 545 546 __ksmbd_close_fd(NULL, fp); 547 } 548 549 struct ksmbd_file *ksmbd_lookup_fd_cguid(char *cguid) 550 { 551 struct ksmbd_file *fp = NULL; 552 unsigned int id; 553 554 read_lock(&global_ft.lock); 555 idr_for_each_entry(global_ft.idr, fp, id) { 556 if (!memcmp(fp->create_guid, 557 cguid, 558 SMB2_CREATE_GUID_SIZE)) { 559 fp = ksmbd_fp_get(fp); 560 break; 561 } 562 } 563 read_unlock(&global_ft.lock); 564 565 return fp; 566 } 567 568 struct ksmbd_file *ksmbd_lookup_fd_inode(struct dentry *dentry) 569 { 570 struct ksmbd_file *lfp; 571 struct ksmbd_inode *ci; 572 struct inode *inode = d_inode(dentry); 573 574 read_lock(&inode_hash_lock); 575 ci = __ksmbd_inode_lookup(dentry); 576 read_unlock(&inode_hash_lock); 577 if (!ci) 578 return NULL; 579 580 down_read(&ci->m_lock); 581 list_for_each_entry(lfp, &ci->m_fp_list, node) { 582 if (inode == file_inode(lfp->filp)) { 583 atomic_dec(&ci->m_count); 584 lfp = ksmbd_fp_get(lfp); 585 up_read(&ci->m_lock); 586 return lfp; 587 } 588 } 589 atomic_dec(&ci->m_count); 590 up_read(&ci->m_lock); 591 return NULL; 592 } 593 594 #define OPEN_ID_TYPE_VOLATILE_ID (0) 595 #define OPEN_ID_TYPE_PERSISTENT_ID (1) 596 597 static void __open_id_set(struct ksmbd_file *fp, u64 id, int type) 598 { 599 if (type == OPEN_ID_TYPE_VOLATILE_ID) 600 fp->volatile_id = id; 601 if (type == OPEN_ID_TYPE_PERSISTENT_ID) 602 fp->persistent_id = id; 603 } 604 605 static int __open_id(struct ksmbd_file_table *ft, struct ksmbd_file *fp, 606 int type) 607 { 608 u64 id = 0; 609 int ret; 610 611 if (type == OPEN_ID_TYPE_VOLATILE_ID && fd_limit_depleted()) { 612 __open_id_set(fp, KSMBD_NO_FID, type); 613 return -EMFILE; 614 } 615 616 idr_preload(KSMBD_DEFAULT_GFP); 617 write_lock(&ft->lock); 618 ret = idr_alloc_cyclic(ft->idr, fp, 0, INT_MAX - 1, GFP_NOWAIT); 619 if (ret >= 0) { 620 id = ret; 621 ret = 0; 622 } else { 623 id = KSMBD_NO_FID; 624 fd_limit_close(); 625 } 626 627 __open_id_set(fp, id, type); 628 write_unlock(&ft->lock); 629 idr_preload_end(); 630 return ret; 631 } 632 633 unsigned int ksmbd_open_durable_fd(struct ksmbd_file *fp) 634 { 635 __open_id(&global_ft, fp, OPEN_ID_TYPE_PERSISTENT_ID); 636 return fp->persistent_id; 637 } 638 639 struct ksmbd_file *ksmbd_open_fd(struct ksmbd_work *work, struct file *filp) 640 { 641 struct ksmbd_file *fp; 642 int ret; 643 644 fp = kmem_cache_zalloc(filp_cache, KSMBD_DEFAULT_GFP); 645 if (!fp) { 646 pr_err("Failed to allocate memory\n"); 647 return ERR_PTR(-ENOMEM); 648 } 649 650 INIT_LIST_HEAD(&fp->blocked_works); 651 INIT_LIST_HEAD(&fp->node); 652 INIT_LIST_HEAD(&fp->lock_list); 653 spin_lock_init(&fp->f_lock); 654 atomic_set(&fp->refcount, 1); 655 656 fp->filp = filp; 657 fp->conn = work->conn; 658 fp->tcon = work->tcon; 659 fp->volatile_id = KSMBD_NO_FID; 660 fp->persistent_id = KSMBD_NO_FID; 661 fp->f_state = FP_NEW; 662 fp->f_ci = ksmbd_inode_get(fp); 663 664 if (!fp->f_ci) { 665 ret = -ENOMEM; 666 goto err_out; 667 } 668 669 ret = __open_id(&work->sess->file_table, fp, OPEN_ID_TYPE_VOLATILE_ID); 670 if (ret) { 671 ksmbd_inode_put(fp->f_ci); 672 goto err_out; 673 } 674 675 atomic_inc(&work->conn->stats.open_files_count); 676 return fp; 677 678 err_out: 679 kmem_cache_free(filp_cache, fp); 680 return ERR_PTR(ret); 681 } 682 683 void ksmbd_update_fstate(struct ksmbd_file_table *ft, struct ksmbd_file *fp, 684 unsigned int state) 685 { 686 if (!fp) 687 return; 688 689 write_lock(&ft->lock); 690 fp->f_state = state; 691 write_unlock(&ft->lock); 692 } 693 694 static int 695 __close_file_table_ids(struct ksmbd_file_table *ft, 696 struct ksmbd_tree_connect *tcon, 697 bool (*skip)(struct ksmbd_tree_connect *tcon, 698 struct ksmbd_file *fp)) 699 { 700 struct ksmbd_file *fp; 701 unsigned int id = 0; 702 int num = 0; 703 704 while (1) { 705 write_lock(&ft->lock); 706 fp = idr_get_next(ft->idr, &id); 707 if (!fp) { 708 write_unlock(&ft->lock); 709 break; 710 } 711 712 if (skip(tcon, fp) || 713 !atomic_dec_and_test(&fp->refcount)) { 714 id++; 715 write_unlock(&ft->lock); 716 continue; 717 } 718 719 set_close_state_blocked_works(fp); 720 idr_remove(ft->idr, fp->volatile_id); 721 fp->volatile_id = KSMBD_NO_FID; 722 write_unlock(&ft->lock); 723 724 down_write(&fp->f_ci->m_lock); 725 list_del_init(&fp->node); 726 up_write(&fp->f_ci->m_lock); 727 728 __ksmbd_close_fd(ft, fp); 729 730 num++; 731 id++; 732 } 733 734 return num; 735 } 736 737 static inline bool is_reconnectable(struct ksmbd_file *fp) 738 { 739 struct oplock_info *opinfo = opinfo_get(fp); 740 bool reconn = false; 741 742 if (!opinfo) 743 return false; 744 745 if (opinfo->op_state != OPLOCK_STATE_NONE) { 746 opinfo_put(opinfo); 747 return false; 748 } 749 750 if (fp->is_resilient || fp->is_persistent) 751 reconn = true; 752 else if (fp->is_durable && opinfo->is_lease && 753 opinfo->o_lease->state & SMB2_LEASE_HANDLE_CACHING_LE) 754 reconn = true; 755 756 else if (fp->is_durable && opinfo->level == SMB2_OPLOCK_LEVEL_BATCH) 757 reconn = true; 758 759 opinfo_put(opinfo); 760 return reconn; 761 } 762 763 static bool tree_conn_fd_check(struct ksmbd_tree_connect *tcon, 764 struct ksmbd_file *fp) 765 { 766 return fp->tcon != tcon; 767 } 768 769 static bool ksmbd_durable_scavenger_alive(void) 770 { 771 if (!durable_scavenger_running) 772 return false; 773 774 if (kthread_should_stop()) 775 return false; 776 777 if (idr_is_empty(global_ft.idr)) 778 return false; 779 780 return true; 781 } 782 783 static void ksmbd_scavenger_dispose_dh(struct list_head *head) 784 { 785 while (!list_empty(head)) { 786 struct ksmbd_file *fp; 787 788 fp = list_first_entry(head, struct ksmbd_file, node); 789 list_del_init(&fp->node); 790 __ksmbd_close_fd(NULL, fp); 791 } 792 } 793 794 static int ksmbd_durable_scavenger(void *dummy) 795 { 796 struct ksmbd_file *fp = NULL; 797 unsigned int id; 798 unsigned int min_timeout = 1; 799 bool found_fp_timeout; 800 LIST_HEAD(scavenger_list); 801 unsigned long remaining_jiffies; 802 803 __module_get(THIS_MODULE); 804 805 set_freezable(); 806 while (ksmbd_durable_scavenger_alive()) { 807 if (try_to_freeze()) 808 continue; 809 810 found_fp_timeout = false; 811 812 remaining_jiffies = wait_event_timeout(dh_wq, 813 ksmbd_durable_scavenger_alive() == false, 814 __msecs_to_jiffies(min_timeout)); 815 if (remaining_jiffies) 816 min_timeout = jiffies_to_msecs(remaining_jiffies); 817 else 818 min_timeout = DURABLE_HANDLE_MAX_TIMEOUT; 819 820 write_lock(&global_ft.lock); 821 idr_for_each_entry(global_ft.idr, fp, id) { 822 if (!fp->durable_timeout) 823 continue; 824 825 if (atomic_read(&fp->refcount) > 1 || 826 fp->conn) 827 continue; 828 829 found_fp_timeout = true; 830 if (fp->durable_scavenger_timeout <= 831 jiffies_to_msecs(jiffies)) { 832 __ksmbd_remove_durable_fd(fp); 833 list_add(&fp->node, &scavenger_list); 834 } else { 835 unsigned long durable_timeout; 836 837 durable_timeout = 838 fp->durable_scavenger_timeout - 839 jiffies_to_msecs(jiffies); 840 841 if (min_timeout > durable_timeout) 842 min_timeout = durable_timeout; 843 } 844 } 845 write_unlock(&global_ft.lock); 846 847 ksmbd_scavenger_dispose_dh(&scavenger_list); 848 849 if (found_fp_timeout == false) 850 break; 851 } 852 853 durable_scavenger_running = false; 854 855 module_put(THIS_MODULE); 856 857 return 0; 858 } 859 860 void ksmbd_launch_ksmbd_durable_scavenger(void) 861 { 862 if (!(server_conf.flags & KSMBD_GLOBAL_FLAG_DURABLE_HANDLE)) 863 return; 864 865 mutex_lock(&durable_scavenger_lock); 866 if (durable_scavenger_running == true) { 867 mutex_unlock(&durable_scavenger_lock); 868 return; 869 } 870 871 durable_scavenger_running = true; 872 873 server_conf.dh_task = kthread_run(ksmbd_durable_scavenger, 874 (void *)NULL, "ksmbd-durable-scavenger"); 875 if (IS_ERR(server_conf.dh_task)) 876 pr_err("cannot start conn thread, err : %ld\n", 877 PTR_ERR(server_conf.dh_task)); 878 mutex_unlock(&durable_scavenger_lock); 879 } 880 881 void ksmbd_stop_durable_scavenger(void) 882 { 883 if (!(server_conf.flags & KSMBD_GLOBAL_FLAG_DURABLE_HANDLE)) 884 return; 885 886 mutex_lock(&durable_scavenger_lock); 887 if (!durable_scavenger_running) { 888 mutex_unlock(&durable_scavenger_lock); 889 return; 890 } 891 892 durable_scavenger_running = false; 893 if (waitqueue_active(&dh_wq)) 894 wake_up(&dh_wq); 895 mutex_unlock(&durable_scavenger_lock); 896 kthread_stop(server_conf.dh_task); 897 } 898 899 static bool session_fd_check(struct ksmbd_tree_connect *tcon, 900 struct ksmbd_file *fp) 901 { 902 struct ksmbd_inode *ci; 903 struct oplock_info *op; 904 struct ksmbd_conn *conn; 905 906 if (!is_reconnectable(fp)) 907 return false; 908 909 conn = fp->conn; 910 ci = fp->f_ci; 911 down_write(&ci->m_lock); 912 list_for_each_entry_rcu(op, &ci->m_op_list, op_entry) { 913 if (op->conn != conn) 914 continue; 915 if (op->conn && atomic_dec_and_test(&op->conn->refcnt)) 916 kfree(op->conn); 917 op->conn = NULL; 918 } 919 up_write(&ci->m_lock); 920 921 fp->conn = NULL; 922 fp->tcon = NULL; 923 fp->volatile_id = KSMBD_NO_FID; 924 925 if (fp->durable_timeout) 926 fp->durable_scavenger_timeout = 927 jiffies_to_msecs(jiffies) + fp->durable_timeout; 928 929 return true; 930 } 931 932 void ksmbd_close_tree_conn_fds(struct ksmbd_work *work) 933 { 934 int num = __close_file_table_ids(&work->sess->file_table, 935 work->tcon, 936 tree_conn_fd_check); 937 938 atomic_sub(num, &work->conn->stats.open_files_count); 939 } 940 941 void ksmbd_close_session_fds(struct ksmbd_work *work) 942 { 943 int num = __close_file_table_ids(&work->sess->file_table, 944 work->tcon, 945 session_fd_check); 946 947 atomic_sub(num, &work->conn->stats.open_files_count); 948 } 949 950 int ksmbd_init_global_file_table(void) 951 { 952 return ksmbd_init_file_table(&global_ft); 953 } 954 955 void ksmbd_free_global_file_table(void) 956 { 957 struct ksmbd_file *fp = NULL; 958 unsigned int id; 959 960 idr_for_each_entry(global_ft.idr, fp, id) { 961 ksmbd_remove_durable_fd(fp); 962 __ksmbd_close_fd(NULL, fp); 963 } 964 965 idr_destroy(global_ft.idr); 966 kfree(global_ft.idr); 967 } 968 969 int ksmbd_validate_name_reconnect(struct ksmbd_share_config *share, 970 struct ksmbd_file *fp, char *name) 971 { 972 char *pathname, *ab_pathname; 973 int ret = 0; 974 975 pathname = kmalloc(PATH_MAX, KSMBD_DEFAULT_GFP); 976 if (!pathname) 977 return -EACCES; 978 979 ab_pathname = d_path(&fp->filp->f_path, pathname, PATH_MAX); 980 if (IS_ERR(ab_pathname)) { 981 kfree(pathname); 982 return -EACCES; 983 } 984 985 if (name && strcmp(&ab_pathname[share->path_sz + 1], name)) { 986 ksmbd_debug(SMB, "invalid name reconnect %s\n", name); 987 ret = -EINVAL; 988 } 989 990 kfree(pathname); 991 992 return ret; 993 } 994 995 int ksmbd_reopen_durable_fd(struct ksmbd_work *work, struct ksmbd_file *fp) 996 { 997 struct ksmbd_inode *ci; 998 struct oplock_info *op; 999 1000 if (!fp->is_durable || fp->conn || fp->tcon) { 1001 pr_err("Invalid durable fd [%p:%p]\n", fp->conn, fp->tcon); 1002 return -EBADF; 1003 } 1004 1005 if (has_file_id(fp->volatile_id)) { 1006 pr_err("Still in use durable fd: %llu\n", fp->volatile_id); 1007 return -EBADF; 1008 } 1009 1010 fp->conn = work->conn; 1011 fp->tcon = work->tcon; 1012 1013 ci = fp->f_ci; 1014 down_write(&ci->m_lock); 1015 list_for_each_entry_rcu(op, &ci->m_op_list, op_entry) { 1016 if (op->conn) 1017 continue; 1018 op->conn = fp->conn; 1019 atomic_inc(&op->conn->refcnt); 1020 } 1021 up_write(&ci->m_lock); 1022 1023 fp->f_state = FP_NEW; 1024 __open_id(&work->sess->file_table, fp, OPEN_ID_TYPE_VOLATILE_ID); 1025 if (!has_file_id(fp->volatile_id)) { 1026 fp->conn = NULL; 1027 fp->tcon = NULL; 1028 return -EBADF; 1029 } 1030 return 0; 1031 } 1032 1033 int ksmbd_init_file_table(struct ksmbd_file_table *ft) 1034 { 1035 ft->idr = kzalloc(sizeof(struct idr), KSMBD_DEFAULT_GFP); 1036 if (!ft->idr) 1037 return -ENOMEM; 1038 1039 idr_init(ft->idr); 1040 rwlock_init(&ft->lock); 1041 return 0; 1042 } 1043 1044 void ksmbd_destroy_file_table(struct ksmbd_file_table *ft) 1045 { 1046 if (!ft->idr) 1047 return; 1048 1049 __close_file_table_ids(ft, NULL, session_fd_check); 1050 idr_destroy(ft->idr); 1051 kfree(ft->idr); 1052 ft->idr = NULL; 1053 } 1054 1055 int ksmbd_init_file_cache(void) 1056 { 1057 filp_cache = kmem_cache_create("ksmbd_file_cache", 1058 sizeof(struct ksmbd_file), 0, 1059 SLAB_HWCACHE_ALIGN, NULL); 1060 if (!filp_cache) 1061 goto out; 1062 1063 init_waitqueue_head(&dh_wq); 1064 1065 return 0; 1066 1067 out: 1068 pr_err("failed to allocate file cache\n"); 1069 return -ENOMEM; 1070 } 1071 1072 void ksmbd_exit_file_cache(void) 1073 { 1074 kmem_cache_destroy(filp_cache); 1075 } 1076