GNU Linux-libre 6.1.86-gnu
[releases.git] / 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/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 }