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
25static unsigned int inode_hash_mask __read_mostly;
26static unsigned int inode_hash_shift __read_mostly;
27static struct hlist_head *inode_hashtable __read_mostly;
28static DEFINE_RWLOCK(inode_hash_lock);
29
30static struct ksmbd_file_table global_ft;
31static atomic_long_t fd_limit;
32static struct kmem_cache *filp_cache;
33
34void ksmbd_set_fd_limit(unsigned long limit)
35{
36	limit = min(limit, get_max_files());
37	atomic_long_set(&fd_limit, limit);
38}
39
40static 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
50static void fd_limit_close(void)
51{
52	atomic_long_inc(&fd_limit);
53}
54
55/*
56 * INODE hash
57 */
58
59static 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
69static 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
85static struct ksmbd_inode *ksmbd_inode_lookup(struct ksmbd_file *fp)
86{
87	return __ksmbd_inode_lookup(fp->filp->f_path.dentry);
88}
89
90struct ksmbd_inode *ksmbd_inode_lookup_lock(struct dentry *d)
91{
92	struct ksmbd_inode *ci;
93
94	read_lock(&inode_hash_lock);
95	ci = __ksmbd_inode_lookup(d);
96	read_unlock(&inode_hash_lock);
97
98	return ci;
99}
100
101int ksmbd_query_inode_status(struct dentry *dentry)
102{
103	struct ksmbd_inode *ci;
104	int ret = KSMBD_INODE_STATUS_UNKNOWN;
105
106	read_lock(&inode_hash_lock);
107	ci = __ksmbd_inode_lookup(dentry);
108	if (ci) {
109		ret = KSMBD_INODE_STATUS_OK;
110		if (ci->m_flags & (S_DEL_PENDING | S_DEL_ON_CLS))
111			ret = KSMBD_INODE_STATUS_PENDING_DELETE;
112		atomic_dec(&ci->m_count);
113	}
114	read_unlock(&inode_hash_lock);
115	return ret;
116}
117
118bool ksmbd_inode_pending_delete(struct ksmbd_file *fp)
119{
120	return (fp->f_ci->m_flags & (S_DEL_PENDING | S_DEL_ON_CLS));
121}
122
123void ksmbd_set_inode_pending_delete(struct ksmbd_file *fp)
124{
125	fp->f_ci->m_flags |= S_DEL_PENDING;
126}
127
128void ksmbd_clear_inode_pending_delete(struct ksmbd_file *fp)
129{
130	fp->f_ci->m_flags &= ~S_DEL_PENDING;
131}
132
133void ksmbd_fd_set_delete_on_close(struct ksmbd_file *fp,
134				  int file_info)
135{
136	if (ksmbd_stream_fd(fp)) {
137		fp->f_ci->m_flags |= S_DEL_ON_CLS_STREAM;
138		return;
139	}
140
141	fp->f_ci->m_flags |= S_DEL_ON_CLS;
142}
143
144static void ksmbd_inode_hash(struct ksmbd_inode *ci)
145{
146	struct hlist_head *b = inode_hashtable +
147		inode_hash(d_inode(ci->m_de)->i_sb, (unsigned long)ci->m_de);
148
149	hlist_add_head(&ci->m_hash, b);
150}
151
152static void ksmbd_inode_unhash(struct ksmbd_inode *ci)
153{
154	write_lock(&inode_hash_lock);
155	hlist_del_init(&ci->m_hash);
156	write_unlock(&inode_hash_lock);
157}
158
159static int ksmbd_inode_init(struct ksmbd_inode *ci, struct ksmbd_file *fp)
160{
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	ci->m_de = fp->filp->f_path.dentry;
170	return 0;
171}
172
173static struct ksmbd_inode *ksmbd_inode_get(struct ksmbd_file *fp)
174{
175	struct ksmbd_inode *ci, *tmpci;
176	int rc;
177
178	read_lock(&inode_hash_lock);
179	ci = ksmbd_inode_lookup(fp);
180	read_unlock(&inode_hash_lock);
181	if (ci)
182		return ci;
183
184	ci = kmalloc(sizeof(struct ksmbd_inode), GFP_KERNEL);
185	if (!ci)
186		return NULL;
187
188	rc = ksmbd_inode_init(ci, fp);
189	if (rc) {
190		pr_err("inode initialized failed\n");
191		kfree(ci);
192		return NULL;
193	}
194
195	write_lock(&inode_hash_lock);
196	tmpci = ksmbd_inode_lookup(fp);
197	if (!tmpci) {
198		ksmbd_inode_hash(ci);
199	} else {
200		kfree(ci);
201		ci = tmpci;
202	}
203	write_unlock(&inode_hash_lock);
204	return ci;
205}
206
207static void ksmbd_inode_free(struct ksmbd_inode *ci)
208{
209	ksmbd_inode_unhash(ci);
210	kfree(ci);
211}
212
213void ksmbd_inode_put(struct ksmbd_inode *ci)
214{
215	if (atomic_dec_and_test(&ci->m_count))
216		ksmbd_inode_free(ci);
217}
218
219int __init ksmbd_inode_hash_init(void)
220{
221	unsigned int loop;
222	unsigned long numentries = 16384;
223	unsigned long bucketsize = sizeof(struct hlist_head);
224	unsigned long size;
225
226	inode_hash_shift = ilog2(numentries);
227	inode_hash_mask = (1 << inode_hash_shift) - 1;
228
229	size = bucketsize << inode_hash_shift;
230
231	/* init master fp hash table */
232	inode_hashtable = vmalloc(size);
233	if (!inode_hashtable)
234		return -ENOMEM;
235
236	for (loop = 0; loop < (1U << inode_hash_shift); loop++)
237		INIT_HLIST_HEAD(&inode_hashtable[loop]);
238	return 0;
239}
240
241void ksmbd_release_inode_hash(void)
242{
243	vfree(inode_hashtable);
244}
245
246static void __ksmbd_inode_close(struct ksmbd_file *fp)
247{
248	struct ksmbd_inode *ci = fp->f_ci;
249	int err;
250	struct file *filp;
251
252	filp = fp->filp;
253	if (ksmbd_stream_fd(fp) && (ci->m_flags & S_DEL_ON_CLS_STREAM)) {
254		ci->m_flags &= ~S_DEL_ON_CLS_STREAM;
255		err = ksmbd_vfs_remove_xattr(file_mnt_idmap(filp),
256					     &filp->f_path,
257					     fp->stream.name);
258		if (err)
259			pr_err("remove xattr failed : %s\n",
260			       fp->stream.name);
261	}
262
263	if (atomic_dec_and_test(&ci->m_count)) {
264		write_lock(&ci->m_lock);
265		if (ci->m_flags & (S_DEL_ON_CLS | S_DEL_PENDING)) {
266			ci->m_flags &= ~(S_DEL_ON_CLS | S_DEL_PENDING);
267			write_unlock(&ci->m_lock);
268			ksmbd_vfs_unlink(filp);
269			write_lock(&ci->m_lock);
270		}
271		write_unlock(&ci->m_lock);
272
273		ksmbd_inode_free(ci);
274	}
275}
276
277static void __ksmbd_remove_durable_fd(struct ksmbd_file *fp)
278{
279	if (!has_file_id(fp->persistent_id))
280		return;
281
282	write_lock(&global_ft.lock);
283	idr_remove(global_ft.idr, fp->persistent_id);
284	write_unlock(&global_ft.lock);
285}
286
287static void __ksmbd_remove_fd(struct ksmbd_file_table *ft, struct ksmbd_file *fp)
288{
289	if (!has_file_id(fp->volatile_id))
290		return;
291
292	write_lock(&fp->f_ci->m_lock);
293	list_del_init(&fp->node);
294	write_unlock(&fp->f_ci->m_lock);
295
296	write_lock(&ft->lock);
297	idr_remove(ft->idr, fp->volatile_id);
298	write_unlock(&ft->lock);
299}
300
301static void __ksmbd_close_fd(struct ksmbd_file_table *ft, struct ksmbd_file *fp)
302{
303	struct file *filp;
304	struct ksmbd_lock *smb_lock, *tmp_lock;
305
306	fd_limit_close();
307	__ksmbd_remove_durable_fd(fp);
308	if (ft)
309		__ksmbd_remove_fd(ft, fp);
310
311	close_id_del_oplock(fp);
312	filp = fp->filp;
313
314	__ksmbd_inode_close(fp);
315	if (!IS_ERR_OR_NULL(filp))
316		fput(filp);
317
318	/* because the reference count of fp is 0, it is guaranteed that
319	 * there are not accesses to fp->lock_list.
320	 */
321	list_for_each_entry_safe(smb_lock, tmp_lock, &fp->lock_list, flist) {
322		spin_lock(&fp->conn->llist_lock);
323		list_del(&smb_lock->clist);
324		spin_unlock(&fp->conn->llist_lock);
325
326		list_del(&smb_lock->flist);
327		locks_free_lock(smb_lock->fl);
328		kfree(smb_lock);
329	}
330
331	if (ksmbd_stream_fd(fp))
332		kfree(fp->stream.name);
333	kmem_cache_free(filp_cache, fp);
334}
335
336static struct ksmbd_file *ksmbd_fp_get(struct ksmbd_file *fp)
337{
338	if (fp->f_state != FP_INITED)
339		return NULL;
340
341	if (!atomic_inc_not_zero(&fp->refcount))
342		return NULL;
343	return fp;
344}
345
346static struct ksmbd_file *__ksmbd_lookup_fd(struct ksmbd_file_table *ft,
347					    u64 id)
348{
349	struct ksmbd_file *fp;
350
351	if (!has_file_id(id))
352		return NULL;
353
354	read_lock(&ft->lock);
355	fp = idr_find(ft->idr, id);
356	if (fp)
357		fp = ksmbd_fp_get(fp);
358	read_unlock(&ft->lock);
359	return fp;
360}
361
362static void __put_fd_final(struct ksmbd_work *work, struct ksmbd_file *fp)
363{
364	__ksmbd_close_fd(&work->sess->file_table, fp);
365	atomic_dec(&work->conn->stats.open_files_count);
366}
367
368static void set_close_state_blocked_works(struct ksmbd_file *fp)
369{
370	struct ksmbd_work *cancel_work;
371
372	spin_lock(&fp->f_lock);
373	list_for_each_entry(cancel_work, &fp->blocked_works,
374				 fp_entry) {
375		cancel_work->state = KSMBD_WORK_CLOSED;
376		cancel_work->cancel_fn(cancel_work->cancel_argv);
377	}
378	spin_unlock(&fp->f_lock);
379}
380
381int ksmbd_close_fd(struct ksmbd_work *work, u64 id)
382{
383	struct ksmbd_file	*fp;
384	struct ksmbd_file_table	*ft;
385
386	if (!has_file_id(id))
387		return 0;
388
389	ft = &work->sess->file_table;
390	write_lock(&ft->lock);
391	fp = idr_find(ft->idr, id);
392	if (fp) {
393		set_close_state_blocked_works(fp);
394
395		if (fp->f_state != FP_INITED)
396			fp = NULL;
397		else {
398			fp->f_state = FP_CLOSED;
399			if (!atomic_dec_and_test(&fp->refcount))
400				fp = NULL;
401		}
402	}
403	write_unlock(&ft->lock);
404
405	if (!fp)
406		return -EINVAL;
407
408	__put_fd_final(work, fp);
409	return 0;
410}
411
412void ksmbd_fd_put(struct ksmbd_work *work, struct ksmbd_file *fp)
413{
414	if (!fp)
415		return;
416
417	if (!atomic_dec_and_test(&fp->refcount))
418		return;
419	__put_fd_final(work, fp);
420}
421
422static bool __sanity_check(struct ksmbd_tree_connect *tcon, struct ksmbd_file *fp)
423{
424	if (!fp)
425		return false;
426	if (fp->tcon != tcon)
427		return false;
428	return true;
429}
430
431struct ksmbd_file *ksmbd_lookup_foreign_fd(struct ksmbd_work *work, u64 id)
432{
433	return __ksmbd_lookup_fd(&work->sess->file_table, id);
434}
435
436struct ksmbd_file *ksmbd_lookup_fd_fast(struct ksmbd_work *work, u64 id)
437{
438	struct ksmbd_file *fp = __ksmbd_lookup_fd(&work->sess->file_table, id);
439
440	if (__sanity_check(work->tcon, fp))
441		return fp;
442
443	ksmbd_fd_put(work, fp);
444	return NULL;
445}
446
447struct ksmbd_file *ksmbd_lookup_fd_slow(struct ksmbd_work *work, u64 id,
448					u64 pid)
449{
450	struct ksmbd_file *fp;
451
452	if (!has_file_id(id)) {
453		id = work->compound_fid;
454		pid = work->compound_pfid;
455	}
456
457	fp = __ksmbd_lookup_fd(&work->sess->file_table, id);
458	if (!__sanity_check(work->tcon, fp)) {
459		ksmbd_fd_put(work, fp);
460		return NULL;
461	}
462	if (fp->persistent_id != pid) {
463		ksmbd_fd_put(work, fp);
464		return NULL;
465	}
466	return fp;
467}
468
469struct ksmbd_file *ksmbd_lookup_global_fd(unsigned long long id)
470{
471	return __ksmbd_lookup_fd(&global_ft, id);
472}
473
474struct ksmbd_file *ksmbd_lookup_durable_fd(unsigned long long id)
475{
476	struct ksmbd_file *fp;
477
478	fp = __ksmbd_lookup_fd(&global_ft, id);
479	if (fp && fp->conn) {
480		ksmbd_put_durable_fd(fp);
481		fp = NULL;
482	}
483
484	return fp;
485}
486
487void ksmbd_put_durable_fd(struct ksmbd_file *fp)
488{
489	if (!atomic_dec_and_test(&fp->refcount))
490		return;
491
492	__ksmbd_close_fd(NULL, fp);
493}
494
495struct ksmbd_file *ksmbd_lookup_fd_cguid(char *cguid)
496{
497	struct ksmbd_file	*fp = NULL;
498	unsigned int		id;
499
500	read_lock(&global_ft.lock);
501	idr_for_each_entry(global_ft.idr, fp, id) {
502		if (!memcmp(fp->create_guid,
503			    cguid,
504			    SMB2_CREATE_GUID_SIZE)) {
505			fp = ksmbd_fp_get(fp);
506			break;
507		}
508	}
509	read_unlock(&global_ft.lock);
510
511	return fp;
512}
513
514struct ksmbd_file *ksmbd_lookup_fd_inode(struct dentry *dentry)
515{
516	struct ksmbd_file	*lfp;
517	struct ksmbd_inode	*ci;
518	struct inode		*inode = d_inode(dentry);
519
520	read_lock(&inode_hash_lock);
521	ci = __ksmbd_inode_lookup(dentry);
522	read_unlock(&inode_hash_lock);
523	if (!ci)
524		return NULL;
525
526	read_lock(&ci->m_lock);
527	list_for_each_entry(lfp, &ci->m_fp_list, node) {
528		if (inode == file_inode(lfp->filp)) {
529			atomic_dec(&ci->m_count);
530			lfp = ksmbd_fp_get(lfp);
531			read_unlock(&ci->m_lock);
532			return lfp;
533		}
534	}
535	atomic_dec(&ci->m_count);
536	read_unlock(&ci->m_lock);
537	return NULL;
538}
539
540#define OPEN_ID_TYPE_VOLATILE_ID	(0)
541#define OPEN_ID_TYPE_PERSISTENT_ID	(1)
542
543static void __open_id_set(struct ksmbd_file *fp, u64 id, int type)
544{
545	if (type == OPEN_ID_TYPE_VOLATILE_ID)
546		fp->volatile_id = id;
547	if (type == OPEN_ID_TYPE_PERSISTENT_ID)
548		fp->persistent_id = id;
549}
550
551static int __open_id(struct ksmbd_file_table *ft, struct ksmbd_file *fp,
552		     int type)
553{
554	u64			id = 0;
555	int			ret;
556
557	if (type == OPEN_ID_TYPE_VOLATILE_ID && fd_limit_depleted()) {
558		__open_id_set(fp, KSMBD_NO_FID, type);
559		return -EMFILE;
560	}
561
562	idr_preload(GFP_KERNEL);
563	write_lock(&ft->lock);
564	ret = idr_alloc_cyclic(ft->idr, fp, 0, INT_MAX - 1, GFP_NOWAIT);
565	if (ret >= 0) {
566		id = ret;
567		ret = 0;
568	} else {
569		id = KSMBD_NO_FID;
570		fd_limit_close();
571	}
572
573	__open_id_set(fp, id, type);
574	write_unlock(&ft->lock);
575	idr_preload_end();
576	return ret;
577}
578
579unsigned int ksmbd_open_durable_fd(struct ksmbd_file *fp)
580{
581	__open_id(&global_ft, fp, OPEN_ID_TYPE_PERSISTENT_ID);
582	return fp->persistent_id;
583}
584
585struct ksmbd_file *ksmbd_open_fd(struct ksmbd_work *work, struct file *filp)
586{
587	struct ksmbd_file *fp;
588	int ret;
589
590	fp = kmem_cache_zalloc(filp_cache, GFP_KERNEL);
591	if (!fp) {
592		pr_err("Failed to allocate memory\n");
593		return ERR_PTR(-ENOMEM);
594	}
595
596	INIT_LIST_HEAD(&fp->blocked_works);
597	INIT_LIST_HEAD(&fp->node);
598	INIT_LIST_HEAD(&fp->lock_list);
599	spin_lock_init(&fp->f_lock);
600	atomic_set(&fp->refcount, 1);
601
602	fp->filp		= filp;
603	fp->conn		= work->conn;
604	fp->tcon		= work->tcon;
605	fp->volatile_id		= KSMBD_NO_FID;
606	fp->persistent_id	= KSMBD_NO_FID;
607	fp->f_state		= FP_NEW;
608	fp->f_ci		= ksmbd_inode_get(fp);
609
610	if (!fp->f_ci) {
611		ret = -ENOMEM;
612		goto err_out;
613	}
614
615	ret = __open_id(&work->sess->file_table, fp, OPEN_ID_TYPE_VOLATILE_ID);
616	if (ret) {
617		ksmbd_inode_put(fp->f_ci);
618		goto err_out;
619	}
620
621	atomic_inc(&work->conn->stats.open_files_count);
622	return fp;
623
624err_out:
625	kmem_cache_free(filp_cache, fp);
626	return ERR_PTR(ret);
627}
628
629void ksmbd_update_fstate(struct ksmbd_file_table *ft, struct ksmbd_file *fp,
630			 unsigned int state)
631{
632	if (!fp)
633		return;
634
635	write_lock(&ft->lock);
636	fp->f_state = state;
637	write_unlock(&ft->lock);
638}
639
640static int
641__close_file_table_ids(struct ksmbd_file_table *ft,
642		       struct ksmbd_tree_connect *tcon,
643		       bool (*skip)(struct ksmbd_tree_connect *tcon,
644				    struct ksmbd_file *fp))
645{
646	unsigned int			id;
647	struct ksmbd_file		*fp;
648	int				num = 0;
649
650	idr_for_each_entry(ft->idr, fp, id) {
651		if (skip(tcon, fp))
652			continue;
653
654		set_close_state_blocked_works(fp);
655
656		if (!atomic_dec_and_test(&fp->refcount))
657			continue;
658		__ksmbd_close_fd(ft, fp);
659		num++;
660	}
661	return num;
662}
663
664static inline bool is_reconnectable(struct ksmbd_file *fp)
665{
666	struct oplock_info *opinfo = opinfo_get(fp);
667	bool reconn = false;
668
669	if (!opinfo)
670		return false;
671
672	if (opinfo->op_state != OPLOCK_STATE_NONE) {
673		opinfo_put(opinfo);
674		return false;
675	}
676
677	if (fp->is_resilient || fp->is_persistent)
678		reconn = true;
679	else if (fp->is_durable && opinfo->is_lease &&
680		 opinfo->o_lease->state & SMB2_LEASE_HANDLE_CACHING_LE)
681		reconn = true;
682
683	else if (fp->is_durable && opinfo->level == SMB2_OPLOCK_LEVEL_BATCH)
684		reconn = true;
685
686	opinfo_put(opinfo);
687	return reconn;
688}
689
690static bool tree_conn_fd_check(struct ksmbd_tree_connect *tcon,
691			       struct ksmbd_file *fp)
692{
693	return fp->tcon != tcon;
694}
695
696static bool session_fd_check(struct ksmbd_tree_connect *tcon,
697			     struct ksmbd_file *fp)
698{
699	struct ksmbd_inode *ci;
700	struct oplock_info *op;
701	struct ksmbd_conn *conn;
702
703	if (!is_reconnectable(fp))
704		return false;
705
706	conn = fp->conn;
707	ci = fp->f_ci;
708	write_lock(&ci->m_lock);
709	list_for_each_entry_rcu(op, &ci->m_op_list, op_entry) {
710		if (op->conn != conn)
711			continue;
712		op->conn = NULL;
713	}
714	write_unlock(&ci->m_lock);
715
716	fp->conn = NULL;
717	fp->tcon = NULL;
718	fp->volatile_id = KSMBD_NO_FID;
719
720	return true;
721}
722
723void ksmbd_close_tree_conn_fds(struct ksmbd_work *work)
724{
725	int num = __close_file_table_ids(&work->sess->file_table,
726					 work->tcon,
727					 tree_conn_fd_check);
728
729	atomic_sub(num, &work->conn->stats.open_files_count);
730}
731
732void ksmbd_close_session_fds(struct ksmbd_work *work)
733{
734	int num = __close_file_table_ids(&work->sess->file_table,
735					 work->tcon,
736					 session_fd_check);
737
738	atomic_sub(num, &work->conn->stats.open_files_count);
739}
740
741int ksmbd_init_global_file_table(void)
742{
743	return ksmbd_init_file_table(&global_ft);
744}
745
746void ksmbd_free_global_file_table(void)
747{
748	struct ksmbd_file	*fp = NULL;
749	unsigned int		id;
750
751	idr_for_each_entry(global_ft.idr, fp, id) {
752		__ksmbd_remove_durable_fd(fp);
753		kmem_cache_free(filp_cache, fp);
754	}
755
756	ksmbd_destroy_file_table(&global_ft);
757}
758
759int ksmbd_validate_name_reconnect(struct ksmbd_share_config *share,
760				  struct ksmbd_file *fp, char *name)
761{
762	char *pathname, *ab_pathname;
763	int ret = 0;
764
765	pathname = kmalloc(PATH_MAX, GFP_KERNEL);
766	if (!pathname)
767		return -EACCES;
768
769	ab_pathname = d_path(&fp->filp->f_path, pathname, PATH_MAX);
770	if (IS_ERR(ab_pathname)) {
771		kfree(pathname);
772		return -EACCES;
773	}
774
775	if (name && strcmp(&ab_pathname[share->path_sz + 1], name)) {
776		ksmbd_debug(SMB, "invalid name reconnect %s\n", name);
777		ret = -EINVAL;
778	}
779
780	kfree(pathname);
781
782	return ret;
783}
784
785int ksmbd_reopen_durable_fd(struct ksmbd_work *work, struct ksmbd_file *fp)
786{
787	struct ksmbd_inode *ci;
788	struct oplock_info *op;
789
790	if (!fp->is_durable || fp->conn || fp->tcon) {
791		pr_err("Invalid durable fd [%p:%p]\n", fp->conn, fp->tcon);
792		return -EBADF;
793	}
794
795	if (has_file_id(fp->volatile_id)) {
796		pr_err("Still in use durable fd: %llu\n", fp->volatile_id);
797		return -EBADF;
798	}
799
800	fp->conn = work->conn;
801	fp->tcon = work->tcon;
802
803	ci = fp->f_ci;
804	write_lock(&ci->m_lock);
805	list_for_each_entry_rcu(op, &ci->m_op_list, op_entry) {
806		if (op->conn)
807			continue;
808		op->conn = fp->conn;
809	}
810	write_unlock(&ci->m_lock);
811
812	__open_id(&work->sess->file_table, fp, OPEN_ID_TYPE_VOLATILE_ID);
813	if (!has_file_id(fp->volatile_id)) {
814		fp->conn = NULL;
815		fp->tcon = NULL;
816		return -EBADF;
817	}
818	return 0;
819}
820
821int ksmbd_init_file_table(struct ksmbd_file_table *ft)
822{
823	ft->idr = kzalloc(sizeof(struct idr), GFP_KERNEL);
824	if (!ft->idr)
825		return -ENOMEM;
826
827	idr_init(ft->idr);
828	rwlock_init(&ft->lock);
829	return 0;
830}
831
832void ksmbd_destroy_file_table(struct ksmbd_file_table *ft)
833{
834	if (!ft->idr)
835		return;
836
837	__close_file_table_ids(ft, NULL, session_fd_check);
838	idr_destroy(ft->idr);
839	kfree(ft->idr);
840	ft->idr = NULL;
841}
842
843int ksmbd_init_file_cache(void)
844{
845	filp_cache = kmem_cache_create("ksmbd_file_cache",
846				       sizeof(struct ksmbd_file), 0,
847				       SLAB_HWCACHE_ALIGN, NULL);
848	if (!filp_cache)
849		goto out;
850
851	return 0;
852
853out:
854	pr_err("failed to allocate file cache\n");
855	return -ENOMEM;
856}
857
858void ksmbd_exit_file_cache(void)
859{
860	kmem_cache_destroy(filp_cache);
861}
862