1/* $NetBSD: kern_fileassoc.c,v 1.38 2023/12/28 12:49:06 hannken Exp $ */
2
3/*-
4 * Copyright (c) 2006 Elad Efrat <elad@NetBSD.org>
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 * 3. The name of the author may not be used to endorse or promote products
16 *    derived from this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30#include <sys/cdefs.h>
31__KERNEL_RCSID(0, "$NetBSD: kern_fileassoc.c,v 1.38 2023/12/28 12:49:06 hannken Exp $");
32
33#include "opt_fileassoc.h"
34
35#include <sys/param.h>
36#include <sys/mount.h>
37#include <sys/queue.h>
38#include <sys/vnode.h>
39#include <sys/errno.h>
40#include <sys/fileassoc.h>
41#include <sys/specificdata.h>
42#include <sys/hash.h>
43#include <sys/kmem.h>
44#include <sys/once.h>
45#include <sys/mutex.h>
46#include <sys/xcall.h>
47
48#define	FILEASSOC_INITIAL_TABLESIZE	128
49
50static specificdata_domain_t fileassoc_domain = NULL;
51static specificdata_key_t fileassoc_mountspecific_key;
52static ONCE_DECL(control);
53
54/*
55 * Assoc entry.
56 * Includes the assoc name for identification and private clear callback.
57 */
58struct fileassoc {
59	LIST_ENTRY(fileassoc) assoc_list;
60	const char *assoc_name;				/* Name. */
61	fileassoc_cleanup_cb_t assoc_cleanup_cb;	/* Clear callback. */
62	specificdata_key_t assoc_key;
63};
64
65static LIST_HEAD(, fileassoc) fileassoc_list;
66
67/* An entry in the per-mount hash table. */
68struct fileassoc_file {
69	fhandle_t *faf_handle;				/* File handle */
70	specificdata_reference faf_data;		/* Assoc data. */
71	u_int faf_nassocs;				/* # of assocs. */
72	LIST_ENTRY(fileassoc_file) faf_list;		/* List pointer. */
73};
74
75LIST_HEAD(fileassoc_hash_entry, fileassoc_file);
76
77struct fileassoc_table {
78	struct fileassoc_hash_entry *tbl_hash;
79	u_long tbl_mask;				/* Hash table mask. */
80	size_t tbl_nslots;				/* Number of slots. */
81	size_t tbl_nused;				/* # of used slots. */
82	specificdata_reference tbl_data;
83};
84
85/*
86 * Hashing function: Takes a number modulus the mask to give back an
87 * index into the hash table.
88 */
89#define FILEASSOC_HASH(tbl, handle)	\
90	(hash32_buf((handle), FHANDLE_SIZE(handle), HASH32_BUF_INIT) \
91	 & ((tbl)->tbl_mask))
92
93/*
94 * Global usage counting.  This is bad for parallelism of updates, but
95 * good for avoiding calls to fileassoc when it's not in use.  Unclear
96 * if parallelism of updates matters much.  If you want to improve
97 * fileassoc(9) update performance, feel free to rip this out as long
98 * as you don't cause the fast paths to take any global locks or incur
99 * memory barriers when fileassoc(9) is not in use.
100 */
101static struct {
102	kmutex_t lock;
103	uint64_t nassocs;
104	volatile bool inuse;
105} fileassoc_global __cacheline_aligned;
106
107static void
108fileassoc_incuse(void)
109{
110
111	mutex_enter(&fileassoc_global.lock);
112	if (fileassoc_global.nassocs++ == 0) {
113		KASSERT(!fileassoc_global.inuse);
114		atomic_store_relaxed(&fileassoc_global.inuse, true);
115		xc_barrier(0);
116	}
117	mutex_exit(&fileassoc_global.lock);
118}
119
120static void
121fileassoc_decuse(void)
122{
123
124	mutex_enter(&fileassoc_global.lock);
125	KASSERT(fileassoc_global.nassocs > 0);
126	KASSERT(fileassoc_global.inuse);
127	if (--fileassoc_global.nassocs == 0)
128		atomic_store_relaxed(&fileassoc_global.inuse, false);
129	mutex_exit(&fileassoc_global.lock);
130}
131
132static bool
133fileassoc_inuse(void)
134{
135
136	return __predict_false(atomic_load_relaxed(&fileassoc_global.inuse));
137}
138
139static void *
140file_getdata(struct fileassoc_file *faf, const struct fileassoc *assoc)
141{
142
143	return specificdata_getspecific(fileassoc_domain, &faf->faf_data,
144	    assoc->assoc_key);
145}
146
147static void
148file_setdata(struct fileassoc_file *faf, const struct fileassoc *assoc,
149    void *data)
150{
151
152	specificdata_setspecific(fileassoc_domain, &faf->faf_data,
153	    assoc->assoc_key, data);
154}
155
156static void
157file_cleanup(struct fileassoc_file *faf, const struct fileassoc *assoc)
158{
159	fileassoc_cleanup_cb_t cb;
160	void *data;
161
162	cb = assoc->assoc_cleanup_cb;
163	if (cb == NULL) {
164		return;
165	}
166	data = file_getdata(faf, assoc);
167	(*cb)(data);
168}
169
170static void
171file_free(struct fileassoc_file *faf)
172{
173	struct fileassoc *assoc;
174
175	LIST_REMOVE(faf, faf_list);
176
177	LIST_FOREACH(assoc, &fileassoc_list, assoc_list) {
178		file_cleanup(faf, assoc);
179		fileassoc_decuse();
180	}
181	vfs_composefh_free(faf->faf_handle);
182	specificdata_fini(fileassoc_domain, &faf->faf_data);
183	kmem_free(faf, sizeof(*faf));
184}
185
186static void
187table_dtor(void *v)
188{
189	struct fileassoc_table *tbl = v;
190	u_long i;
191
192	/* Remove all entries from the table and lists */
193	for (i = 0; i < tbl->tbl_nslots; i++) {
194		struct fileassoc_file *faf;
195
196		while ((faf = LIST_FIRST(&tbl->tbl_hash[i])) != NULL) {
197			file_free(faf);
198		}
199	}
200
201	/* Remove hash table and sysctl node */
202	hashdone(tbl->tbl_hash, HASH_LIST, tbl->tbl_mask);
203	specificdata_fini(fileassoc_domain, &tbl->tbl_data);
204	kmem_free(tbl, sizeof(*tbl));
205}
206
207/*
208 * Initialize the fileassoc subsystem.
209 */
210static int
211fileassoc_init(void)
212{
213	int error;
214
215	error = mount_specific_key_create(&fileassoc_mountspecific_key,
216	    table_dtor);
217	if (error) {
218		return error;
219	}
220	fileassoc_domain = specificdata_domain_create();
221
222	mutex_init(&fileassoc_global.lock, MUTEX_DEFAULT, IPL_NONE);
223
224	return 0;
225}
226
227/*
228 * Register a new assoc.
229 */
230int
231fileassoc_register(const char *name, fileassoc_cleanup_cb_t cleanup_cb,
232    fileassoc_t *result)
233{
234	int error;
235	specificdata_key_t key;
236	struct fileassoc *assoc;
237
238	error = RUN_ONCE(&control, fileassoc_init);
239	if (error) {
240		return error;
241	}
242	error = specificdata_key_create(fileassoc_domain, &key, NULL);
243	if (error) {
244		return error;
245	}
246	assoc = kmem_alloc(sizeof(*assoc), KM_SLEEP);
247	assoc->assoc_name = name;
248	assoc->assoc_cleanup_cb = cleanup_cb;
249	assoc->assoc_key = key;
250
251	LIST_INSERT_HEAD(&fileassoc_list, assoc, assoc_list);
252
253	*result = assoc;
254
255	return 0;
256}
257
258/*
259 * Deregister an assoc.
260 */
261int
262fileassoc_deregister(fileassoc_t assoc)
263{
264
265	LIST_REMOVE(assoc, assoc_list);
266	specificdata_key_delete(fileassoc_domain, assoc->assoc_key);
267	kmem_free(assoc, sizeof(*assoc));
268
269	return 0;
270}
271
272/*
273 * Get the hash table for the specified device.
274 */
275static struct fileassoc_table *
276fileassoc_table_lookup(struct mount *mp)
277{
278	int error;
279
280	if (!fileassoc_inuse())
281		return NULL;
282
283	error = RUN_ONCE(&control, fileassoc_init);
284	if (error) {
285		return NULL;
286	}
287	return mount_getspecific(mp, fileassoc_mountspecific_key);
288}
289
290/*
291 * Perform a lookup on a hash table.  If hint is non-zero then use the value
292 * of the hint as the identifier instead of performing a lookup for the
293 * fileid.
294 */
295static struct fileassoc_file *
296fileassoc_file_lookup(struct vnode *vp, fhandle_t *hint)
297{
298	struct fileassoc_table *tbl;
299	struct fileassoc_hash_entry *hash_entry;
300	struct fileassoc_file *faf;
301	size_t indx;
302	fhandle_t *th;
303	int error;
304
305	tbl = fileassoc_table_lookup(vp->v_mount);
306	if (tbl == NULL) {
307		return NULL;
308	}
309
310	if (hint == NULL) {
311		error = vfs_composefh_alloc(vp, &th);
312		if (error)
313			return (NULL);
314	} else {
315		th = hint;
316	}
317
318	indx = FILEASSOC_HASH(tbl, th);
319	hash_entry = &(tbl->tbl_hash[indx]);
320
321	LIST_FOREACH(faf, hash_entry, faf_list) {
322		if (((FHANDLE_FILEID(faf->faf_handle)->fid_len ==
323		     FHANDLE_FILEID(th)->fid_len)) &&
324		    (memcmp(FHANDLE_FILEID(faf->faf_handle), FHANDLE_FILEID(th),
325			   (FHANDLE_FILEID(th))->fid_len) == 0)) {
326			break;
327		}
328	}
329
330	if (hint == NULL)
331		vfs_composefh_free(th);
332
333	return faf;
334}
335
336/*
337 * Return assoc data associated with a vnode.
338 */
339void *
340fileassoc_lookup(struct vnode *vp, fileassoc_t assoc)
341{
342	struct fileassoc_file *faf;
343
344	faf = fileassoc_file_lookup(vp, NULL);
345	if (faf == NULL)
346		return (NULL);
347
348	return file_getdata(faf, assoc);
349}
350
351static struct fileassoc_table *
352fileassoc_table_resize(struct fileassoc_table *tbl)
353{
354	struct fileassoc_table *newtbl;
355	u_long i;
356
357	/*
358	 * Allocate a new table. Like the condition in fileassoc_file_add(),
359	 * this is also temporary -- just double the number of slots.
360	 */
361	newtbl = kmem_zalloc(sizeof(*newtbl), KM_SLEEP);
362	newtbl->tbl_nslots = (tbl->tbl_nslots * 2);
363	if (newtbl->tbl_nslots < tbl->tbl_nslots)
364		newtbl->tbl_nslots = tbl->tbl_nslots;
365	newtbl->tbl_hash = hashinit(newtbl->tbl_nslots, HASH_LIST,
366	    true, &newtbl->tbl_mask);
367	newtbl->tbl_nused = 0;
368	specificdata_init(fileassoc_domain, &newtbl->tbl_data);
369
370	/* XXX we need to make sure nothing uses fileassoc here! */
371
372	for (i = 0; i < tbl->tbl_nslots; i++) {
373		struct fileassoc_file *faf;
374
375		while ((faf = LIST_FIRST(&tbl->tbl_hash[i])) != NULL) {
376			struct fileassoc_hash_entry *hash_entry;
377			size_t indx;
378
379			LIST_REMOVE(faf, faf_list);
380
381			indx = FILEASSOC_HASH(newtbl, faf->faf_handle);
382			hash_entry = &(newtbl->tbl_hash[indx]);
383
384			LIST_INSERT_HEAD(hash_entry, faf, faf_list);
385
386			newtbl->tbl_nused++;
387		}
388	}
389
390	if (tbl->tbl_nused != newtbl->tbl_nused)
391		panic("fileassoc_table_resize: inconsistency detected! "
392		    "needed %zu entries, got %zu", tbl->tbl_nused,
393		    newtbl->tbl_nused);
394
395	hashdone(tbl->tbl_hash, HASH_LIST, tbl->tbl_mask);
396	specificdata_fini(fileassoc_domain, &tbl->tbl_data);
397	kmem_free(tbl, sizeof(*tbl));
398
399	return (newtbl);
400}
401
402/*
403 * Create a new fileassoc table.
404 */
405static struct fileassoc_table *
406fileassoc_table_add(struct mount *mp)
407{
408	struct fileassoc_table *tbl;
409
410	/* Check for existing table for device. */
411	tbl = fileassoc_table_lookup(mp);
412	if (tbl != NULL)
413		return (tbl);
414
415	/* Allocate and initialize a table. */
416	tbl = kmem_zalloc(sizeof(*tbl), KM_SLEEP);
417	tbl->tbl_nslots = FILEASSOC_INITIAL_TABLESIZE;
418	tbl->tbl_hash = hashinit(tbl->tbl_nslots, HASH_LIST, true,
419	    &tbl->tbl_mask);
420	tbl->tbl_nused = 0;
421	specificdata_init(fileassoc_domain, &tbl->tbl_data);
422
423	mount_setspecific(mp, fileassoc_mountspecific_key, tbl);
424
425	return (tbl);
426}
427
428/*
429 * Delete a table.
430 */
431int
432fileassoc_table_delete(struct mount *mp)
433{
434	struct fileassoc_table *tbl;
435
436	tbl = fileassoc_table_lookup(mp);
437	if (tbl == NULL)
438		return (EEXIST);
439
440	mount_setspecific(mp, fileassoc_mountspecific_key, NULL);
441	table_dtor(tbl);
442
443	return (0);
444}
445
446/*
447 * Run a callback for each assoc in a table.
448 */
449int
450fileassoc_table_run(struct mount *mp, fileassoc_t assoc, fileassoc_cb_t cb,
451    void *cookie)
452{
453	struct fileassoc_table *tbl;
454	u_long i;
455
456	tbl = fileassoc_table_lookup(mp);
457	if (tbl == NULL)
458		return (EEXIST);
459
460	for (i = 0; i < tbl->tbl_nslots; i++) {
461		struct fileassoc_file *faf;
462
463		LIST_FOREACH(faf, &tbl->tbl_hash[i], faf_list) {
464			void *data;
465
466			data = file_getdata(faf, assoc);
467			if (data != NULL)
468				cb(data, cookie);
469		}
470	}
471
472	return (0);
473}
474
475/*
476 * Clear a table for a given assoc.
477 */
478int
479fileassoc_table_clear(struct mount *mp, fileassoc_t assoc)
480{
481	struct fileassoc_table *tbl;
482	u_long i;
483
484	tbl = fileassoc_table_lookup(mp);
485	if (tbl == NULL)
486		return (EEXIST);
487
488	for (i = 0; i < tbl->tbl_nslots; i++) {
489		struct fileassoc_file *faf;
490
491		LIST_FOREACH(faf, &tbl->tbl_hash[i], faf_list) {
492			file_cleanup(faf, assoc);
493			file_setdata(faf, assoc, NULL);
494			/* XXX missing faf->faf_nassocs--? */
495			fileassoc_decuse();
496		}
497	}
498
499	return (0);
500}
501
502/*
503 * Add a file entry to a table.
504 */
505static struct fileassoc_file *
506fileassoc_file_add(struct vnode *vp, fhandle_t *hint)
507{
508	struct fileassoc_table *tbl;
509	struct fileassoc_hash_entry *hash_entry;
510	struct fileassoc_file *faf;
511	size_t indx;
512	fhandle_t *th;
513	int error;
514
515	if (hint == NULL) {
516		error = vfs_composefh_alloc(vp, &th);
517		if (error)
518			return (NULL);
519	} else
520		th = hint;
521
522	faf = fileassoc_file_lookup(vp, th);
523	if (faf != NULL) {
524		if (hint == NULL)
525			vfs_composefh_free(th);
526
527		return (faf);
528	}
529
530	tbl = fileassoc_table_lookup(vp->v_mount);
531	if (tbl == NULL) {
532		tbl = fileassoc_table_add(vp->v_mount);
533	}
534
535	indx = FILEASSOC_HASH(tbl, th);
536	hash_entry = &(tbl->tbl_hash[indx]);
537
538	faf = kmem_zalloc(sizeof(*faf), KM_SLEEP);
539	faf->faf_handle = th;
540	specificdata_init(fileassoc_domain, &faf->faf_data);
541	LIST_INSERT_HEAD(hash_entry, faf, faf_list);
542
543	/*
544	 * This decides when we need to resize the table. For now,
545	 * resize it whenever we "filled" up the number of slots it
546	 * has. That's not really true unless of course we had zero
547	 * collisions. Think positive! :)
548	 */
549	if (++(tbl->tbl_nused) == tbl->tbl_nslots) {
550		struct fileassoc_table *newtbl;
551
552		newtbl = fileassoc_table_resize(tbl);
553		mount_setspecific(vp->v_mount, fileassoc_mountspecific_key,
554		    newtbl);
555	}
556
557	return (faf);
558}
559
560/*
561 * Delete a file entry from a table.
562 */
563int
564fileassoc_file_delete(struct vnode *vp)
565{
566	struct fileassoc_table *tbl;
567	struct fileassoc_file *faf;
568
569	if (!fileassoc_inuse())
570		return ENOENT;
571
572	KERNEL_LOCK(1, NULL);
573
574	faf = fileassoc_file_lookup(vp, NULL);
575	if (faf == NULL) {
576		KERNEL_UNLOCK_ONE(NULL);
577		return (ENOENT);
578	}
579
580	file_free(faf);
581
582	tbl = fileassoc_table_lookup(vp->v_mount);
583	KASSERT(tbl != NULL);
584	--(tbl->tbl_nused); /* XXX gc? */
585
586	KERNEL_UNLOCK_ONE(NULL);
587
588	return (0);
589}
590
591/*
592 * Add an assoc to a vnode.
593 */
594int
595fileassoc_add(struct vnode *vp, fileassoc_t assoc, void *data)
596{
597	struct fileassoc_file *faf;
598	void *olddata;
599
600	faf = fileassoc_file_lookup(vp, NULL);
601	if (faf == NULL) {
602		faf = fileassoc_file_add(vp, NULL);
603		if (faf == NULL)
604			return (ENOTDIR);
605	}
606
607	olddata = file_getdata(faf, assoc);
608	if (olddata != NULL)
609		return (EEXIST);
610
611	fileassoc_incuse();
612
613	file_setdata(faf, assoc, data);
614
615	faf->faf_nassocs++;
616
617	return (0);
618}
619
620/*
621 * Clear an assoc from a vnode.
622 */
623int
624fileassoc_clear(struct vnode *vp, fileassoc_t assoc)
625{
626	struct fileassoc_file *faf;
627
628	faf = fileassoc_file_lookup(vp, NULL);
629	if (faf == NULL)
630		return (ENOENT);
631
632	file_cleanup(faf, assoc);
633	file_setdata(faf, assoc, NULL);
634
635	--(faf->faf_nassocs); /* XXX gc? */
636
637	fileassoc_decuse();
638
639	return (0);
640}
641