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 
ksmbd_set_fd_limit(unsigned long limit)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 
fd_limit_depleted(void)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 
fd_limit_close(void)50 static void fd_limit_close(void)
51 {
52 	atomic_long_inc(&fd_limit);
53 }
54 
55 /*
56  * INODE hash
57  */
58 
inode_hash(struct super_block * sb,unsigned long hashval)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 
__ksmbd_inode_lookup(struct inode * inode)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 
ksmbd_inode_lookup(struct ksmbd_file * fp)85 static struct ksmbd_inode *ksmbd_inode_lookup(struct ksmbd_file *fp)
86 {
87 	return __ksmbd_inode_lookup(file_inode(fp->filp));
88 }
89 
ksmbd_inode_lookup_by_vfsinode(struct inode * inode)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 
ksmbd_query_inode_status(struct inode * inode)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 
ksmbd_inode_pending_delete(struct ksmbd_file * fp)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 
ksmbd_set_inode_pending_delete(struct ksmbd_file * fp)122 void ksmbd_set_inode_pending_delete(struct ksmbd_file *fp)
123 {
124 	fp->f_ci->m_flags |= S_DEL_PENDING;
125 }
126 
ksmbd_clear_inode_pending_delete(struct ksmbd_file * fp)127 void ksmbd_clear_inode_pending_delete(struct ksmbd_file *fp)
128 {
129 	fp->f_ci->m_flags &= ~S_DEL_PENDING;
130 }
131 
ksmbd_fd_set_delete_on_close(struct ksmbd_file * fp,int file_info)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 
ksmbd_inode_hash(struct ksmbd_inode * ci)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 
ksmbd_inode_unhash(struct ksmbd_inode * ci)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 
ksmbd_inode_init(struct ksmbd_inode * ci,struct ksmbd_file * fp)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 
ksmbd_inode_get(struct ksmbd_file * fp)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 
ksmbd_inode_free(struct ksmbd_inode * ci)206 static void ksmbd_inode_free(struct ksmbd_inode *ci)
207 {
208 	ksmbd_inode_unhash(ci);
209 	kfree(ci);
210 }
211 
ksmbd_inode_put(struct ksmbd_inode * ci)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 
ksmbd_inode_hash_init(void)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 
ksmbd_release_inode_hash(void)240 void ksmbd_release_inode_hash(void)
241 {
242 	vfree(inode_hashtable);
243 }
244 
__ksmbd_inode_close(struct ksmbd_file * fp)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 
__ksmbd_remove_durable_fd(struct ksmbd_file * fp)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 
__ksmbd_remove_fd(struct ksmbd_file_table * ft,struct ksmbd_file * fp)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 
__ksmbd_close_fd(struct ksmbd_file_table * ft,struct ksmbd_file * fp)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 
ksmbd_fp_get(struct ksmbd_file * fp)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 
__ksmbd_lookup_fd(struct ksmbd_file_table * ft,u64 id)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 
__put_fd_final(struct ksmbd_work * work,struct ksmbd_file * fp)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 
set_close_state_blocked_works(struct ksmbd_file * fp)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 
ksmbd_close_fd(struct ksmbd_work * work,u64 id)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 
ksmbd_fd_put(struct ksmbd_work * work,struct ksmbd_file * fp)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 
__sanity_check(struct ksmbd_tree_connect * tcon,struct ksmbd_file * fp)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 
ksmbd_lookup_foreign_fd(struct ksmbd_work * work,u64 id)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 
ksmbd_lookup_fd_fast(struct ksmbd_work * work,u64 id)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 
ksmbd_lookup_fd_slow(struct ksmbd_work * work,u64 id,u64 pid)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 
ksmbd_lookup_durable_fd(unsigned long long id)467 struct ksmbd_file *ksmbd_lookup_durable_fd(unsigned long long id)
468 {
469 	return __ksmbd_lookup_fd(&global_ft, id);
470 }
471 
ksmbd_lookup_fd_cguid(char * cguid)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 
ksmbd_lookup_fd_inode(struct inode * inode)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 
__open_id_set(struct ksmbd_file * fp,u64 id,int type)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 
__open_id(struct ksmbd_file_table * ft,struct ksmbd_file * fp,int type)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 
ksmbd_open_durable_fd(struct ksmbd_file * fp)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 
ksmbd_open_fd(struct ksmbd_work * work,struct file * filp)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 
ksmbd_update_fstate(struct ksmbd_file_table * ft,struct ksmbd_file * fp,unsigned int state)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
__close_file_table_ids(struct ksmbd_file_table * ft,struct ksmbd_tree_connect * tcon,bool (* skip)(struct ksmbd_tree_connect * tcon,struct ksmbd_file * fp))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 
tree_conn_fd_check(struct ksmbd_tree_connect * tcon,struct ksmbd_file * fp)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 
session_fd_check(struct ksmbd_tree_connect * tcon,struct ksmbd_file * fp)644 static bool session_fd_check(struct ksmbd_tree_connect *tcon,
645 			     struct ksmbd_file *fp)
646 {
647 	return false;
648 }
649 
ksmbd_close_tree_conn_fds(struct ksmbd_work * work)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 
ksmbd_close_session_fds(struct ksmbd_work * work)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 
ksmbd_init_global_file_table(void)668 int ksmbd_init_global_file_table(void)
669 {
670 	return ksmbd_init_file_table(&global_ft);
671 }
672 
ksmbd_free_global_file_table(void)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 
ksmbd_init_file_table(struct ksmbd_file_table * ft)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 
ksmbd_destroy_file_table(struct ksmbd_file_table * ft)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 
ksmbd_init_file_cache(void)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 
ksmbd_exit_file_cache(void)723 void ksmbd_exit_file_cache(void)
724 {
725 	kmem_cache_destroy(filp_cache);
726 }
727