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