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 12 #include "glob.h" 13 #include "vfs_cache.h" 14 #include "oplock.h" 15 #include "vfs.h" 16 #include "connection.h" 17 #include "mgmt/tree_connect.h" 18 #include "mgmt/user_session.h" 19 #include "smb_common.h" 20 21 #define S_DEL_PENDING 1 22 #define S_DEL_ON_CLS 2 23 #define S_DEL_ON_CLS_STREAM 8 24 25 static unsigned int inode_hash_mask __read_mostly; 26 static unsigned int inode_hash_shift __read_mostly; 27 static struct hlist_head *inode_hashtable __read_mostly; 28 static DEFINE_RWLOCK(inode_hash_lock); 29 30 static struct ksmbd_file_table global_ft; 31 static atomic_long_t fd_limit; 32 static struct kmem_cache *filp_cache; 33 34 void ksmbd_set_fd_limit(unsigned long limit) 35 { 36 limit = min(limit, get_max_files()); 37 atomic_long_set(&fd_limit, limit); 38 } 39 40 static bool fd_limit_depleted(void) 41 { 42 long v = atomic_long_dec_return(&fd_limit); 43 44 if (v >= 0) 45 return false; 46 atomic_long_inc(&fd_limit); 47 return true; 48 } 49 50 static void fd_limit_close(void) 51 { 52 atomic_long_inc(&fd_limit); 53 } 54 55 /* 56 * INODE hash 57 */ 58 59 static unsigned long inode_hash(struct super_block *sb, unsigned long hashval) 60 { 61 unsigned long tmp; 62 63 tmp = (hashval * (unsigned long)sb) ^ (GOLDEN_RATIO_PRIME + hashval) / 64 L1_CACHE_BYTES; 65 tmp = tmp ^ ((tmp ^ GOLDEN_RATIO_PRIME) >> inode_hash_shift); 66 return tmp & inode_hash_mask; 67 } 68 69 static struct ksmbd_inode *__ksmbd_inode_lookup(struct inode *inode) 70 { 71 struct hlist_head *head = inode_hashtable + 72 inode_hash(inode->i_sb, inode->i_ino); 73 struct ksmbd_inode *ci = NULL, *ret_ci = NULL; 74 75 hlist_for_each_entry(ci, head, m_hash) { 76 if (ci->m_inode == inode) { 77 if (atomic_inc_not_zero(&ci->m_count)) 78 ret_ci = ci; 79 break; 80 } 81 } 82 return ret_ci; 83 } 84 85 static struct ksmbd_inode *ksmbd_inode_lookup(struct ksmbd_file *fp) 86 { 87 return __ksmbd_inode_lookup(file_inode(fp->filp)); 88 } 89 90 static struct ksmbd_inode *ksmbd_inode_lookup_by_vfsinode(struct inode *inode) 91 { 92 struct ksmbd_inode *ci; 93 94 read_lock(&inode_hash_lock); 95 ci = __ksmbd_inode_lookup(inode); 96 read_unlock(&inode_hash_lock); 97 return ci; 98 } 99 100 int ksmbd_query_inode_status(struct inode *inode) 101 { 102 struct ksmbd_inode *ci; 103 int ret = KSMBD_INODE_STATUS_UNKNOWN; 104 105 read_lock(&inode_hash_lock); 106 ci = __ksmbd_inode_lookup(inode); 107 if (ci) { 108 ret = KSMBD_INODE_STATUS_OK; 109 if (ci->m_flags & (S_DEL_PENDING | S_DEL_ON_CLS)) 110 ret = KSMBD_INODE_STATUS_PENDING_DELETE; 111 atomic_dec(&ci->m_count); 112 } 113 read_unlock(&inode_hash_lock); 114 return ret; 115 } 116 117 bool ksmbd_inode_pending_delete(struct ksmbd_file *fp) 118 { 119 return (fp->f_ci->m_flags & (S_DEL_PENDING | S_DEL_ON_CLS)); 120 } 121 122 void ksmbd_set_inode_pending_delete(struct ksmbd_file *fp) 123 { 124 fp->f_ci->m_flags |= S_DEL_PENDING; 125 } 126 127 void ksmbd_clear_inode_pending_delete(struct ksmbd_file *fp) 128 { 129 fp->f_ci->m_flags &= ~S_DEL_PENDING; 130 } 131 132 void ksmbd_fd_set_delete_on_close(struct ksmbd_file *fp, 133 int file_info) 134 { 135 if (ksmbd_stream_fd(fp)) { 136 fp->f_ci->m_flags |= S_DEL_ON_CLS_STREAM; 137 return; 138 } 139 140 fp->f_ci->m_flags |= S_DEL_ON_CLS; 141 } 142 143 static void ksmbd_inode_hash(struct ksmbd_inode *ci) 144 { 145 struct hlist_head *b = inode_hashtable + 146 inode_hash(ci->m_inode->i_sb, ci->m_inode->i_ino); 147 148 hlist_add_head(&ci->m_hash, b); 149 } 150 151 static void ksmbd_inode_unhash(struct ksmbd_inode *ci) 152 { 153 write_lock(&inode_hash_lock); 154 hlist_del_init(&ci->m_hash); 155 write_unlock(&inode_hash_lock); 156 } 157 158 static int ksmbd_inode_init(struct ksmbd_inode *ci, struct ksmbd_file *fp) 159 { 160 ci->m_inode = file_inode(fp->filp); 161 atomic_set(&ci->m_count, 1); 162 atomic_set(&ci->op_count, 0); 163 atomic_set(&ci->sop_count, 0); 164 ci->m_flags = 0; 165 ci->m_fattr = 0; 166 INIT_LIST_HEAD(&ci->m_fp_list); 167 INIT_LIST_HEAD(&ci->m_op_list); 168 rwlock_init(&ci->m_lock); 169 return 0; 170 } 171 172 static struct ksmbd_inode *ksmbd_inode_get(struct ksmbd_file *fp) 173 { 174 struct ksmbd_inode *ci, *tmpci; 175 int rc; 176 177 read_lock(&inode_hash_lock); 178 ci = ksmbd_inode_lookup(fp); 179 read_unlock(&inode_hash_lock); 180 if (ci) 181 return ci; 182 183 ci = kmalloc(sizeof(struct ksmbd_inode), GFP_KERNEL); 184 if (!ci) 185 return NULL; 186 187 rc = ksmbd_inode_init(ci, fp); 188 if (rc) { 189 pr_err("inode initialized failed\n"); 190 kfree(ci); 191 return NULL; 192 } 193 194 write_lock(&inode_hash_lock); 195 tmpci = ksmbd_inode_lookup(fp); 196 if (!tmpci) { 197 ksmbd_inode_hash(ci); 198 } else { 199 kfree(ci); 200 ci = tmpci; 201 } 202 write_unlock(&inode_hash_lock); 203 return ci; 204 } 205 206 static void ksmbd_inode_free(struct ksmbd_inode *ci) 207 { 208 ksmbd_inode_unhash(ci); 209 kfree(ci); 210 } 211 212 static void ksmbd_inode_put(struct ksmbd_inode *ci) 213 { 214 if (atomic_dec_and_test(&ci->m_count)) 215 ksmbd_inode_free(ci); 216 } 217 218 int __init ksmbd_inode_hash_init(void) 219 { 220 unsigned int loop; 221 unsigned long numentries = 16384; 222 unsigned long bucketsize = sizeof(struct hlist_head); 223 unsigned long size; 224 225 inode_hash_shift = ilog2(numentries); 226 inode_hash_mask = (1 << inode_hash_shift) - 1; 227 228 size = bucketsize << inode_hash_shift; 229 230 /* init master fp hash table */ 231 inode_hashtable = vmalloc(size); 232 if (!inode_hashtable) 233 return -ENOMEM; 234 235 for (loop = 0; loop < (1U << inode_hash_shift); loop++) 236 INIT_HLIST_HEAD(&inode_hashtable[loop]); 237 return 0; 238 } 239 240 void ksmbd_release_inode_hash(void) 241 { 242 vfree(inode_hashtable); 243 } 244 245 static void __ksmbd_inode_close(struct ksmbd_file *fp) 246 { 247 struct ksmbd_inode *ci = fp->f_ci; 248 int err; 249 struct file *filp; 250 251 filp = fp->filp; 252 if (ksmbd_stream_fd(fp) && (ci->m_flags & S_DEL_ON_CLS_STREAM)) { 253 ci->m_flags &= ~S_DEL_ON_CLS_STREAM; 254 err = ksmbd_vfs_remove_xattr(file_mnt_idmap(filp), 255 &filp->f_path, 256 fp->stream.name); 257 if (err) 258 pr_err("remove xattr failed : %s\n", 259 fp->stream.name); 260 } 261 262 if (atomic_dec_and_test(&ci->m_count)) { 263 write_lock(&ci->m_lock); 264 if (ci->m_flags & (S_DEL_ON_CLS | S_DEL_PENDING)) { 265 ci->m_flags &= ~(S_DEL_ON_CLS | S_DEL_PENDING); 266 write_unlock(&ci->m_lock); 267 ksmbd_vfs_unlink(filp); 268 write_lock(&ci->m_lock); 269 } 270 write_unlock(&ci->m_lock); 271 272 ksmbd_inode_free(ci); 273 } 274 } 275 276 static void __ksmbd_remove_durable_fd(struct ksmbd_file *fp) 277 { 278 if (!has_file_id(fp->persistent_id)) 279 return; 280 281 write_lock(&global_ft.lock); 282 idr_remove(global_ft.idr, fp->persistent_id); 283 write_unlock(&global_ft.lock); 284 } 285 286 static void __ksmbd_remove_fd(struct ksmbd_file_table *ft, struct ksmbd_file *fp) 287 { 288 if (!has_file_id(fp->volatile_id)) 289 return; 290 291 write_lock(&fp->f_ci->m_lock); 292 list_del_init(&fp->node); 293 write_unlock(&fp->f_ci->m_lock); 294 295 write_lock(&ft->lock); 296 idr_remove(ft->idr, fp->volatile_id); 297 write_unlock(&ft->lock); 298 } 299 300 static void __ksmbd_close_fd(struct ksmbd_file_table *ft, struct ksmbd_file *fp) 301 { 302 struct file *filp; 303 struct ksmbd_lock *smb_lock, *tmp_lock; 304 305 fd_limit_close(); 306 __ksmbd_remove_durable_fd(fp); 307 __ksmbd_remove_fd(ft, fp); 308 309 close_id_del_oplock(fp); 310 filp = fp->filp; 311 312 __ksmbd_inode_close(fp); 313 if (!IS_ERR_OR_NULL(filp)) 314 fput(filp); 315 316 /* because the reference count of fp is 0, it is guaranteed that 317 * there are not accesses to fp->lock_list. 318 */ 319 list_for_each_entry_safe(smb_lock, tmp_lock, &fp->lock_list, flist) { 320 spin_lock(&fp->conn->llist_lock); 321 list_del(&smb_lock->clist); 322 spin_unlock(&fp->conn->llist_lock); 323 324 list_del(&smb_lock->flist); 325 locks_free_lock(smb_lock->fl); 326 kfree(smb_lock); 327 } 328 329 if (ksmbd_stream_fd(fp)) 330 kfree(fp->stream.name); 331 kmem_cache_free(filp_cache, fp); 332 } 333 334 static struct ksmbd_file *ksmbd_fp_get(struct ksmbd_file *fp) 335 { 336 if (fp->f_state != FP_INITED) 337 return NULL; 338 339 if (!atomic_inc_not_zero(&fp->refcount)) 340 return NULL; 341 return fp; 342 } 343 344 static struct ksmbd_file *__ksmbd_lookup_fd(struct ksmbd_file_table *ft, 345 u64 id) 346 { 347 struct ksmbd_file *fp; 348 349 if (!has_file_id(id)) 350 return NULL; 351 352 read_lock(&ft->lock); 353 fp = idr_find(ft->idr, id); 354 if (fp) 355 fp = ksmbd_fp_get(fp); 356 read_unlock(&ft->lock); 357 return fp; 358 } 359 360 static void __put_fd_final(struct ksmbd_work *work, struct ksmbd_file *fp) 361 { 362 __ksmbd_close_fd(&work->sess->file_table, fp); 363 atomic_dec(&work->conn->stats.open_files_count); 364 } 365 366 static void set_close_state_blocked_works(struct ksmbd_file *fp) 367 { 368 struct ksmbd_work *cancel_work; 369 370 spin_lock(&fp->f_lock); 371 list_for_each_entry(cancel_work, &fp->blocked_works, 372 fp_entry) { 373 cancel_work->state = KSMBD_WORK_CLOSED; 374 cancel_work->cancel_fn(cancel_work->cancel_argv); 375 } 376 spin_unlock(&fp->f_lock); 377 } 378 379 int ksmbd_close_fd(struct ksmbd_work *work, u64 id) 380 { 381 struct ksmbd_file *fp; 382 struct ksmbd_file_table *ft; 383 384 if (!has_file_id(id)) 385 return 0; 386 387 ft = &work->sess->file_table; 388 write_lock(&ft->lock); 389 fp = idr_find(ft->idr, id); 390 if (fp) { 391 set_close_state_blocked_works(fp); 392 393 if (fp->f_state != FP_INITED) 394 fp = NULL; 395 else { 396 fp->f_state = FP_CLOSED; 397 if (!atomic_dec_and_test(&fp->refcount)) 398 fp = NULL; 399 } 400 } 401 write_unlock(&ft->lock); 402 403 if (!fp) 404 return -EINVAL; 405 406 __put_fd_final(work, fp); 407 return 0; 408 } 409 410 void ksmbd_fd_put(struct ksmbd_work *work, struct ksmbd_file *fp) 411 { 412 if (!fp) 413 return; 414 415 if (!atomic_dec_and_test(&fp->refcount)) 416 return; 417 __put_fd_final(work, fp); 418 } 419 420 static bool __sanity_check(struct ksmbd_tree_connect *tcon, struct ksmbd_file *fp) 421 { 422 if (!fp) 423 return false; 424 if (fp->tcon != tcon) 425 return false; 426 return true; 427 } 428 429 struct ksmbd_file *ksmbd_lookup_foreign_fd(struct ksmbd_work *work, u64 id) 430 { 431 return __ksmbd_lookup_fd(&work->sess->file_table, id); 432 } 433 434 struct ksmbd_file *ksmbd_lookup_fd_fast(struct ksmbd_work *work, u64 id) 435 { 436 struct ksmbd_file *fp = __ksmbd_lookup_fd(&work->sess->file_table, id); 437 438 if (__sanity_check(work->tcon, fp)) 439 return fp; 440 441 ksmbd_fd_put(work, fp); 442 return NULL; 443 } 444 445 struct ksmbd_file *ksmbd_lookup_fd_slow(struct ksmbd_work *work, u64 id, 446 u64 pid) 447 { 448 struct ksmbd_file *fp; 449 450 if (!has_file_id(id)) { 451 id = work->compound_fid; 452 pid = work->compound_pfid; 453 } 454 455 fp = __ksmbd_lookup_fd(&work->sess->file_table, id); 456 if (!__sanity_check(work->tcon, fp)) { 457 ksmbd_fd_put(work, fp); 458 return NULL; 459 } 460 if (fp->persistent_id != pid) { 461 ksmbd_fd_put(work, fp); 462 return NULL; 463 } 464 return fp; 465 } 466 467 struct ksmbd_file *ksmbd_lookup_durable_fd(unsigned long long id) 468 { 469 return __ksmbd_lookup_fd(&global_ft, id); 470 } 471 472 struct ksmbd_file *ksmbd_lookup_fd_cguid(char *cguid) 473 { 474 struct ksmbd_file *fp = NULL; 475 unsigned int id; 476 477 read_lock(&global_ft.lock); 478 idr_for_each_entry(global_ft.idr, fp, id) { 479 if (!memcmp(fp->create_guid, 480 cguid, 481 SMB2_CREATE_GUID_SIZE)) { 482 fp = ksmbd_fp_get(fp); 483 break; 484 } 485 } 486 read_unlock(&global_ft.lock); 487 488 return fp; 489 } 490 491 struct ksmbd_file *ksmbd_lookup_fd_inode(struct inode *inode) 492 { 493 struct ksmbd_file *lfp; 494 struct ksmbd_inode *ci; 495 496 ci = ksmbd_inode_lookup_by_vfsinode(inode); 497 if (!ci) 498 return NULL; 499 500 read_lock(&ci->m_lock); 501 list_for_each_entry(lfp, &ci->m_fp_list, node) { 502 if (inode == file_inode(lfp->filp)) { 503 atomic_dec(&ci->m_count); 504 lfp = ksmbd_fp_get(lfp); 505 read_unlock(&ci->m_lock); 506 return lfp; 507 } 508 } 509 atomic_dec(&ci->m_count); 510 read_unlock(&ci->m_lock); 511 return NULL; 512 } 513 514 #define OPEN_ID_TYPE_VOLATILE_ID (0) 515 #define OPEN_ID_TYPE_PERSISTENT_ID (1) 516 517 static void __open_id_set(struct ksmbd_file *fp, u64 id, int type) 518 { 519 if (type == OPEN_ID_TYPE_VOLATILE_ID) 520 fp->volatile_id = id; 521 if (type == OPEN_ID_TYPE_PERSISTENT_ID) 522 fp->persistent_id = id; 523 } 524 525 static int __open_id(struct ksmbd_file_table *ft, struct ksmbd_file *fp, 526 int type) 527 { 528 u64 id = 0; 529 int ret; 530 531 if (type == OPEN_ID_TYPE_VOLATILE_ID && fd_limit_depleted()) { 532 __open_id_set(fp, KSMBD_NO_FID, type); 533 return -EMFILE; 534 } 535 536 idr_preload(GFP_KERNEL); 537 write_lock(&ft->lock); 538 ret = idr_alloc_cyclic(ft->idr, fp, 0, INT_MAX - 1, GFP_NOWAIT); 539 if (ret >= 0) { 540 id = ret; 541 ret = 0; 542 } else { 543 id = KSMBD_NO_FID; 544 fd_limit_close(); 545 } 546 547 __open_id_set(fp, id, type); 548 write_unlock(&ft->lock); 549 idr_preload_end(); 550 return ret; 551 } 552 553 unsigned int ksmbd_open_durable_fd(struct ksmbd_file *fp) 554 { 555 __open_id(&global_ft, fp, OPEN_ID_TYPE_PERSISTENT_ID); 556 return fp->persistent_id; 557 } 558 559 struct ksmbd_file *ksmbd_open_fd(struct ksmbd_work *work, struct file *filp) 560 { 561 struct ksmbd_file *fp; 562 int ret; 563 564 fp = kmem_cache_zalloc(filp_cache, GFP_KERNEL); 565 if (!fp) { 566 pr_err("Failed to allocate memory\n"); 567 return ERR_PTR(-ENOMEM); 568 } 569 570 INIT_LIST_HEAD(&fp->blocked_works); 571 INIT_LIST_HEAD(&fp->node); 572 INIT_LIST_HEAD(&fp->lock_list); 573 spin_lock_init(&fp->f_lock); 574 atomic_set(&fp->refcount, 1); 575 576 fp->filp = filp; 577 fp->conn = work->conn; 578 fp->tcon = work->tcon; 579 fp->volatile_id = KSMBD_NO_FID; 580 fp->persistent_id = KSMBD_NO_FID; 581 fp->f_state = FP_NEW; 582 fp->f_ci = ksmbd_inode_get(fp); 583 584 if (!fp->f_ci) { 585 ret = -ENOMEM; 586 goto err_out; 587 } 588 589 ret = __open_id(&work->sess->file_table, fp, OPEN_ID_TYPE_VOLATILE_ID); 590 if (ret) { 591 ksmbd_inode_put(fp->f_ci); 592 goto err_out; 593 } 594 595 atomic_inc(&work->conn->stats.open_files_count); 596 return fp; 597 598 err_out: 599 kmem_cache_free(filp_cache, fp); 600 return ERR_PTR(ret); 601 } 602 603 void ksmbd_update_fstate(struct ksmbd_file_table *ft, struct ksmbd_file *fp, 604 unsigned int state) 605 { 606 if (!fp) 607 return; 608 609 write_lock(&ft->lock); 610 fp->f_state = state; 611 write_unlock(&ft->lock); 612 } 613 614 static int 615 __close_file_table_ids(struct ksmbd_file_table *ft, 616 struct ksmbd_tree_connect *tcon, 617 bool (*skip)(struct ksmbd_tree_connect *tcon, 618 struct ksmbd_file *fp)) 619 { 620 unsigned int id; 621 struct ksmbd_file *fp; 622 int num = 0; 623 624 idr_for_each_entry(ft->idr, fp, id) { 625 if (skip(tcon, fp)) 626 continue; 627 628 set_close_state_blocked_works(fp); 629 630 if (!atomic_dec_and_test(&fp->refcount)) 631 continue; 632 __ksmbd_close_fd(ft, fp); 633 num++; 634 } 635 return num; 636 } 637 638 static bool tree_conn_fd_check(struct ksmbd_tree_connect *tcon, 639 struct ksmbd_file *fp) 640 { 641 return fp->tcon != tcon; 642 } 643 644 static bool session_fd_check(struct ksmbd_tree_connect *tcon, 645 struct ksmbd_file *fp) 646 { 647 return false; 648 } 649 650 void ksmbd_close_tree_conn_fds(struct ksmbd_work *work) 651 { 652 int num = __close_file_table_ids(&work->sess->file_table, 653 work->tcon, 654 tree_conn_fd_check); 655 656 atomic_sub(num, &work->conn->stats.open_files_count); 657 } 658 659 void ksmbd_close_session_fds(struct ksmbd_work *work) 660 { 661 int num = __close_file_table_ids(&work->sess->file_table, 662 work->tcon, 663 session_fd_check); 664 665 atomic_sub(num, &work->conn->stats.open_files_count); 666 } 667 668 int ksmbd_init_global_file_table(void) 669 { 670 return ksmbd_init_file_table(&global_ft); 671 } 672 673 void ksmbd_free_global_file_table(void) 674 { 675 struct ksmbd_file *fp = NULL; 676 unsigned int id; 677 678 idr_for_each_entry(global_ft.idr, fp, id) { 679 __ksmbd_remove_durable_fd(fp); 680 kmem_cache_free(filp_cache, fp); 681 } 682 683 ksmbd_destroy_file_table(&global_ft); 684 } 685 686 int ksmbd_init_file_table(struct ksmbd_file_table *ft) 687 { 688 ft->idr = kzalloc(sizeof(struct idr), GFP_KERNEL); 689 if (!ft->idr) 690 return -ENOMEM; 691 692 idr_init(ft->idr); 693 rwlock_init(&ft->lock); 694 return 0; 695 } 696 697 void ksmbd_destroy_file_table(struct ksmbd_file_table *ft) 698 { 699 if (!ft->idr) 700 return; 701 702 __close_file_table_ids(ft, NULL, session_fd_check); 703 idr_destroy(ft->idr); 704 kfree(ft->idr); 705 ft->idr = NULL; 706 } 707 708 int ksmbd_init_file_cache(void) 709 { 710 filp_cache = kmem_cache_create("ksmbd_file_cache", 711 sizeof(struct ksmbd_file), 0, 712 SLAB_HWCACHE_ALIGN, NULL); 713 if (!filp_cache) 714 goto out; 715 716 return 0; 717 718 out: 719 pr_err("failed to allocate file cache\n"); 720 return -ENOMEM; 721 } 722 723 void ksmbd_exit_file_cache(void) 724 { 725 kmem_cache_destroy(filp_cache); 726 } 727