smb/server/vfs_cache.c

   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/slab.h>
   9 #include <linux/vmalloc.h>
  10
  11 #include "glob.h"
  12 #include "vfs_cache.h"
  13 #include "oplock.h"
  14 #include "vfs.h"
  15 #include "connection.h"
  16 #include "mgmt/tree_connect.h"
  17 #include "mgmt/user_session.h"
  18 #include "smb_common.h"
  19
  20 #define S_DEL_PENDING                   1
  21 #define S_DEL_ON_CLS                    2
  22 #define S_DEL_ON_CLS_STREAM             8
  23
  24 static unsigned int inode_hash_mask __read_mostly;
  25 static unsigned int inode_hash_shift __read_mostly;
  26 static struct hlist_head *inode_hashtable __read_mostly;
  27 static DEFINE_RWLOCK(inode_hash_lock);
  28
  29 static struct ksmbd_file_table global_ft;
  30 static atomic_long_t fd_limit;
  31 static struct kmem_cache *filp_cache;
  32
  33 void ksmbd_set_fd_limit(unsigned long limit)
  34 {
  35         limit = min(limit, get_max_files());
  36         atomic_long_set(&fd_limit, limit);
  37 }
  38
  39 static bool fd_limit_depleted(void)
  40 {
  41         long v = atomic_long_dec_return(&fd_limit);
  42
  43         if (v >= 0)
  44                 return false;
  45         atomic_long_inc(&fd_limit);
  46         return true;
  47 }
  48
  49 static void fd_limit_close(void)
  50 {
  51         atomic_long_inc(&fd_limit);
  52 }
  53
  54 /*
  55  * INODE hash
  56  */
  57
  58 static unsigned long inode_hash(struct super_block *sb, unsigned long hashval)
  59 {
  60         unsigned long tmp;
  61
  62         tmp = (hashval * (unsigned long)sb) ^ (GOLDEN_RATIO_PRIME + hashval) /
  63                 L1_CACHE_BYTES;
  64         tmp = tmp ^ ((tmp ^ GOLDEN_RATIO_PRIME) >> inode_hash_shift);
  65         return tmp & inode_hash_mask;
  66 }
  67
  68 static struct ksmbd_inode *__ksmbd_inode_lookup(struct dentry *de)
  69 {
  70         struct hlist_head *head = inode_hashtable +
  71                 inode_hash(d_inode(de)->i_sb, (unsigned long)de);
  72         struct ksmbd_inode *ci = NULL, *ret_ci = NULL;
  73
  74         hlist_for_each_entry(ci, head, m_hash) {
  75                 if (ci->m_de == de) {
  76                         if (atomic_inc_not_zero(&ci->m_count))
  77                                 ret_ci = ci;
  78                         break;
  79                 }
  80         }
  81         return ret_ci;
  82 }
  83
  84 static struct ksmbd_inode *ksmbd_inode_lookup(struct ksmbd_file *fp)
  85 {
  86         return __ksmbd_inode_lookup(fp->filp->f_path.dentry);
  87 }
  88
  89 struct ksmbd_inode *ksmbd_inode_lookup_lock(struct dentry *d)
  90 {
  91         struct ksmbd_inode *ci;
  92
  93         read_lock(&inode_hash_lock);
  94         ci = __ksmbd_inode_lookup(d);
  95         read_unlock(&inode_hash_lock);
  96
  97         return ci;
  98 }
  99
 100 int ksmbd_query_inode_status(struct dentry *dentry)
 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(dentry);
 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(d_inode(ci->m_de)->i_sb, (unsigned long)ci->m_de);
 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         atomic_set(&ci->m_count, 1);
 161         atomic_set(&ci->op_count, 0);
 162         atomic_set(&ci->sop_count, 0);
 163         ci->m_flags = 0;
 164         ci->m_fattr = 0;
 165         INIT_LIST_HEAD(&ci->m_fp_list);
 166         INIT_LIST_HEAD(&ci->m_op_list);
 167         rwlock_init(&ci->m_lock);
 168         ci->m_de = fp->filp->f_path.dentry;
 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 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_user_ns(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 dentry *dentry)
 492 {
 493         struct ksmbd_file       *lfp;
 494         struct ksmbd_inode      *ci;
 495         struct inode            *inode = d_inode(dentry);
 496
 497         read_lock(&inode_hash_lock);
 498         ci = __ksmbd_inode_lookup(dentry);
 499         read_unlock(&inode_hash_lock);
 500         if (!ci)
 501                 return NULL;
 502
 503         read_lock(&ci->m_lock);
 504         list_for_each_entry(lfp, &ci->m_fp_list, node) {
 505                 if (inode == file_inode(lfp->filp)) {
 506                         atomic_dec(&ci->m_count);
 507                         lfp = ksmbd_fp_get(lfp);
 508                         read_unlock(&ci->m_lock);
 509                         return lfp;
 510                 }
 511         }
 512         atomic_dec(&ci->m_count);
 513         read_unlock(&ci->m_lock);
 514         return NULL;
 515 }
 516
 517 #define OPEN_ID_TYPE_VOLATILE_ID        (0)
 518 #define OPEN_ID_TYPE_PERSISTENT_ID      (1)
 519
 520 static void __open_id_set(struct ksmbd_file *fp, u64 id, int type)
 521 {
 522         if (type == OPEN_ID_TYPE_VOLATILE_ID)
 523                 fp->volatile_id = id;
 524         if (type == OPEN_ID_TYPE_PERSISTENT_ID)
 525                 fp->persistent_id = id;
 526 }
 527
 528 static int __open_id(struct ksmbd_file_table *ft, struct ksmbd_file *fp,
 529                      int type)
 530 {
 531         u64                     id = 0;
 532         int                     ret;
 533
 534         if (type == OPEN_ID_TYPE_VOLATILE_ID && fd_limit_depleted()) {
 535                 __open_id_set(fp, KSMBD_NO_FID, type);
 536                 return -EMFILE;
 537         }
 538
 539         idr_preload(GFP_KERNEL);
 540         write_lock(&ft->lock);
 541         ret = idr_alloc_cyclic(ft->idr, fp, 0, INT_MAX - 1, GFP_NOWAIT);
 542         if (ret >= 0) {
 543                 id = ret;
 544                 ret = 0;
 545         } else {
 546                 id = KSMBD_NO_FID;
 547                 fd_limit_close();
 548         }
 549
 550         __open_id_set(fp, id, type);
 551         write_unlock(&ft->lock);
 552         idr_preload_end();
 553         return ret;
 554 }
 555
 556 unsigned int ksmbd_open_durable_fd(struct ksmbd_file *fp)
 557 {
 558         __open_id(&global_ft, fp, OPEN_ID_TYPE_PERSISTENT_ID);
 559         return fp->persistent_id;
 560 }
 561
 562 struct ksmbd_file *ksmbd_open_fd(struct ksmbd_work *work, struct file *filp)
 563 {
 564         struct ksmbd_file *fp;
 565         int ret;
 566
 567         fp = kmem_cache_zalloc(filp_cache, GFP_KERNEL);
 568         if (!fp) {
 569                 pr_err("Failed to allocate memory\n");
 570                 return ERR_PTR(-ENOMEM);
 571         }
 572
 573         INIT_LIST_HEAD(&fp->blocked_works);
 574         INIT_LIST_HEAD(&fp->node);
 575         INIT_LIST_HEAD(&fp->lock_list);
 576         spin_lock_init(&fp->f_lock);
 577         atomic_set(&fp->refcount, 1);
 578
 579         fp->filp                = filp;
 580         fp->conn                = work->conn;
 581         fp->tcon                = work->tcon;
 582         fp->volatile_id         = KSMBD_NO_FID;
 583         fp->persistent_id       = KSMBD_NO_FID;
 584         fp->f_state             = FP_NEW;
 585         fp->f_ci                = ksmbd_inode_get(fp);
 586
 587         if (!fp->f_ci) {
 588                 ret = -ENOMEM;
 589                 goto err_out;
 590         }
 591
 592         ret = __open_id(&work->sess->file_table, fp, OPEN_ID_TYPE_VOLATILE_ID);
 593         if (ret) {
 594                 ksmbd_inode_put(fp->f_ci);
 595                 goto err_out;
 596         }
 597
 598         atomic_inc(&work->conn->stats.open_files_count);
 599         return fp;
 600
 601 err_out:
 602         kmem_cache_free(filp_cache, fp);
 603         return ERR_PTR(ret);
 604 }
 605
 606 void ksmbd_update_fstate(struct ksmbd_file_table *ft, struct ksmbd_file *fp,
 607                          unsigned int state)
 608 {
 609         if (!fp)
 610                 return;
 611
 612         write_lock(&ft->lock);
 613         fp->f_state = state;
 614         write_unlock(&ft->lock);
 615 }
 616
 617 static int
 618 __close_file_table_ids(struct ksmbd_file_table *ft,
 619                        struct ksmbd_tree_connect *tcon,
 620                        bool (*skip)(struct ksmbd_tree_connect *tcon,
 621                                     struct ksmbd_file *fp))
 622 {
 623         unsigned int                    id;
 624         struct ksmbd_file               *fp;
 625         int                             num = 0;
 626
 627         idr_for_each_entry(ft->idr, fp, id) {
 628                 if (skip(tcon, fp))
 629                         continue;
 630
 631                 set_close_state_blocked_works(fp);
 632
 633                 if (!atomic_dec_and_test(&fp->refcount))
 634                         continue;
 635                 __ksmbd_close_fd(ft, fp);
 636                 num++;
 637         }
 638         return num;
 639 }
 640
 641 static bool tree_conn_fd_check(struct ksmbd_tree_connect *tcon,
 642                                struct ksmbd_file *fp)
 643 {
 644         return fp->tcon != tcon;
 645 }
 646
 647 static bool session_fd_check(struct ksmbd_tree_connect *tcon,
 648                              struct ksmbd_file *fp)
 649 {
 650         return false;
 651 }
 652
 653 void ksmbd_close_tree_conn_fds(struct ksmbd_work *work)
 654 {
 655         int num = __close_file_table_ids(&work->sess->file_table,
 656                                          work->tcon,
 657                                          tree_conn_fd_check);
 658
 659         atomic_sub(num, &work->conn->stats.open_files_count);
 660 }
 661
 662 void ksmbd_close_session_fds(struct ksmbd_work *work)
 663 {
 664         int num = __close_file_table_ids(&work->sess->file_table,
 665                                          work->tcon,
 666                                          session_fd_check);
 667
 668         atomic_sub(num, &work->conn->stats.open_files_count);
 669 }
 670
 671 int ksmbd_init_global_file_table(void)
 672 {
 673         return ksmbd_init_file_table(&global_ft);
 674 }
 675
 676 void ksmbd_free_global_file_table(void)
 677 {
 678         struct ksmbd_file       *fp = NULL;
 679         unsigned int            id;
 680
 681         idr_for_each_entry(global_ft.idr, fp, id) {
 682                 __ksmbd_remove_durable_fd(fp);
 683                 kmem_cache_free(filp_cache, fp);
 684         }
 685
 686         ksmbd_destroy_file_table(&global_ft);
 687 }
 688
 689 int ksmbd_init_file_table(struct ksmbd_file_table *ft)
 690 {
 691         ft->idr = kzalloc(sizeof(struct idr), GFP_KERNEL);
 692         if (!ft->idr)
 693                 return -ENOMEM;
 694
 695         idr_init(ft->idr);
 696         rwlock_init(&ft->lock);
 697         return 0;
 698 }
 699
 700 void ksmbd_destroy_file_table(struct ksmbd_file_table *ft)
 701 {
 702         if (!ft->idr)
 703                 return;
 704
 705         __close_file_table_ids(ft, NULL, session_fd_check);
 706         idr_destroy(ft->idr);
 707         kfree(ft->idr);
 708         ft->idr = NULL;
 709 }
 710
 711 int ksmbd_init_file_cache(void)
 712 {
 713         filp_cache = kmem_cache_create("ksmbd_file_cache",
 714                                        sizeof(struct ksmbd_file), 0,
 715                                        SLAB_HWCACHE_ALIGN, NULL);
 716         if (!filp_cache)
 717                 goto out;
 718
 719         return 0;
 720
 721 out:
 722         pr_err("failed to allocate file cache\n");
 723         return -ENOMEM;
 724 }
 725
 726 void ksmbd_exit_file_cache(void)
 727 {
 728         kmem_cache_destroy(filp_cache);
 729 }