fs/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/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 }