1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22/*
23 * Copyright (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Copyright 2015 Nexenta Systems, Inc. All rights reserved.
25 */
26
27#include <sys/types.h>
28#include <sys/t_lock.h>
29#include <sys/param.h>
30#include <sys/systm.h>
31#include <sys/sysmacros.h>
32#include <sys/cmn_err.h>
33#include <sys/list.h>
34#include <sys/sunddi.h>
35
36#include <sys/stropts.h>
37#include <sys/socket.h>
38#include <sys/socketvar.h>
39
40#include <fs/sockfs/sockcommon.h>
41#include <fs/sockfs/sockfilter_impl.h>
42#include <fs/sockfs/socktpi.h>
43
44/*
45 * Socket Parameters
46 *
47 * Socket parameter (struct sockparams) entries represent the socket types
48 * available on the system.
49 *
50 * Flags (sp_flags):
51 *
52 * SOCKPARAMS_EPHEMERAL: A temporary sockparams entry that will be deleted
53 * as soon as its' ref count drops to zero. In addition, ephemeral entries will
54 * never be hooked onto the global sockparams list. Ephemeral entries are
55 * created when application requests to create a socket using an application
56 * supplied device path, or when a socket is falling back to TPI.
57 *
58 * Lock order:
59 *   The lock order is sockconf_lock -> sp_lock.
60 */
61extern int 	kobj_path_exists(char *, int);
62
63static int 	sockparams_sdev_init(struct sockparams *, char *, int);
64static void 	sockparams_sdev_fini(struct sockparams *);
65
66/*
67 * Global sockparams list (populated via soconfig(1M)).
68 */
69static list_t sphead;
70
71/*
72 * List of ephemeral sockparams.
73 */
74static list_t sp_ephem_list;
75
76/* Global kstats for sockparams */
77typedef struct sockparams_g_stats {
78	kstat_named_t spgs_ephem_nalloc;
79	kstat_named_t spgs_ephem_nreuse;
80} sockparams_g_stats_t;
81
82static sockparams_g_stats_t sp_g_stats;
83static kstat_t *sp_g_kstat;
84
85
86void
87sockparams_init(void)
88{
89	list_create(&sphead, sizeof (struct sockparams),
90	    offsetof(struct sockparams, sp_node));
91	list_create(&sp_ephem_list, sizeof (struct sockparams),
92	    offsetof(struct sockparams, sp_node));
93
94	kstat_named_init(&sp_g_stats.spgs_ephem_nalloc, "ephemeral_nalloc",
95	    KSTAT_DATA_UINT64);
96	kstat_named_init(&sp_g_stats.spgs_ephem_nreuse, "ephemeral_nreuse",
97	    KSTAT_DATA_UINT64);
98
99	sp_g_kstat = kstat_create("sockfs", 0, "sockparams", "misc",
100	    KSTAT_TYPE_NAMED, sizeof (sp_g_stats) / sizeof (kstat_named_t),
101	    KSTAT_FLAG_VIRTUAL);
102	if (sp_g_kstat == NULL)
103		return;
104
105	sp_g_kstat->ks_data = &sp_g_stats;
106
107	kstat_install(sp_g_kstat);
108}
109
110static int
111sockparams_kstat_update(kstat_t *ksp, int rw)
112{
113	struct sockparams *sp = ksp->ks_private;
114	sockparams_stats_t *sps = ksp->ks_data;
115
116	if (rw == KSTAT_WRITE)
117		return (EACCES);
118
119	sps->sps_nactive.value.ui64 = sp->sp_refcnt;
120
121	return (0);
122}
123
124/*
125 * Setup kstats for the given sockparams entry.
126 */
127static void
128sockparams_kstat_init(struct sockparams *sp)
129{
130	char name[KSTAT_STRLEN];
131
132	(void) snprintf(name, KSTAT_STRLEN, "socket_%d_%d_%d", sp->sp_family,
133	    sp->sp_type, sp->sp_protocol);
134
135	sp->sp_kstat = kstat_create("sockfs", 0, name, "misc", KSTAT_TYPE_NAMED,
136	    sizeof (sockparams_stats_t) / sizeof (kstat_named_t),
137	    KSTAT_FLAG_VIRTUAL);
138
139	if (sp->sp_kstat == NULL)
140		return;
141
142	sp->sp_kstat->ks_data = &sp->sp_stats;
143	sp->sp_kstat->ks_update = sockparams_kstat_update;
144	sp->sp_kstat->ks_private = sp;
145	kstat_install(sp->sp_kstat);
146}
147
148static void
149sockparams_kstat_fini(struct sockparams *sp)
150{
151	if (sp->sp_kstat != NULL) {
152		kstat_delete(sp->sp_kstat);
153		sp->sp_kstat = NULL;
154	}
155}
156
157/*
158 * sockparams_create(int family, int type, int protocol, char *modname,
159 *     char *devpath, int devpathlen, int flags, int kmflags, int *errorp)
160 *
161 * Create a new sockparams entry.
162 *
163 * Arguments:
164 *   family, type, protocol: specifies the socket type
165 *   modname: Name of the module associated with the socket type. The
166 *            module can be NULL if a device path is given, in which
167 *            case the TPI module is used.
168 *   devpath: Path to the STREAMS device. Must be NULL for non-STREAMS
169 *            based transports.
170 *   devpathlen: Length of the devpath string. The argument can be 0,
171 *            indicating that devpath was allocated statically, and should
172 *            not be freed when the sockparams entry is destroyed.
173 *
174 *   flags  : SOCKPARAMS_EPHEMERAL is the only flag that is allowed.
175 *   kmflags: KM_{NO,}SLEEP
176 *   errorp : Value-return argument, set when an error occurs.
177 *
178 * Returns:
179 *   On success a new sockparams entry is returned, and *errorp is set
180 *   to 0. On failure NULL is returned and *errorp is set to indicate the
181 *   type of error that occured.
182 *
183 * Notes:
184 *   devpath and modname are freed upon failure.
185 */
186struct sockparams *
187sockparams_create(int family, int type, int protocol, char *modname,
188    char *devpath, int devpathlen, int flags, int kmflags, int *errorp)
189{
190	struct sockparams *sp = NULL;
191	size_t size;
192
193	ASSERT((flags & ~SOCKPARAMS_EPHEMERAL) == 0);
194	if (flags & ~SOCKPARAMS_EPHEMERAL) {
195		*errorp = EINVAL;
196		goto error;
197	}
198
199	/* either a module or device must be given, but not both */
200	if (modname == NULL && devpath == NULL) {
201		*errorp = EINVAL;
202		goto error;
203	}
204
205	sp = kmem_zalloc(sizeof (*sp), kmflags);
206	if (sp == NULL) {
207		*errorp = ENOMEM;
208		goto error;
209	}
210	sp->sp_family = family;
211	sp->sp_type = type;
212	sp->sp_protocol = protocol;
213	sp->sp_refcnt = 0;
214	sp->sp_flags = flags;
215
216	list_create(&sp->sp_auto_filters, sizeof (sp_filter_t),
217	    offsetof(sp_filter_t, spf_node));
218	list_create(&sp->sp_prog_filters, sizeof (sp_filter_t),
219	    offsetof(sp_filter_t, spf_node));
220
221	kstat_named_init(&sp->sp_stats.sps_nfallback, "nfallback",
222	    KSTAT_DATA_UINT64);
223	kstat_named_init(&sp->sp_stats.sps_nactive, "nactive",
224	    KSTAT_DATA_UINT64);
225	kstat_named_init(&sp->sp_stats.sps_ncreate, "ncreate",
226	    KSTAT_DATA_UINT64);
227
228	/*
229	 * Track how many ephemeral entries we have created.
230	 */
231	if (sp->sp_flags & SOCKPARAMS_EPHEMERAL)
232		sp_g_stats.spgs_ephem_nalloc.value.ui64++;
233
234	if (modname != NULL) {
235		sp->sp_smod_name = modname;
236	} else {
237		size = strlen(SOTPI_SMOD_NAME) + 1;
238		modname = kmem_zalloc(size, kmflags);
239		if (modname == NULL) {
240			*errorp = ENOMEM;
241			goto error;
242		}
243		sp->sp_smod_name = modname;
244		(void) sprintf(sp->sp_smod_name, "%s", SOTPI_SMOD_NAME);
245	}
246
247	if (devpath != NULL) {
248		/* Set up the device entry. */
249		*errorp = sockparams_sdev_init(sp, devpath, devpathlen);
250		if (*errorp != 0)
251			goto error;
252	}
253
254	mutex_init(&sp->sp_lock, NULL, MUTEX_DEFAULT, NULL);
255	*errorp = 0;
256	return (sp);
257error:
258	ASSERT(*errorp != 0);
259	if (modname != NULL)
260		kmem_free(modname, strlen(modname) + 1);
261	if (devpathlen != 0)
262		kmem_free(devpath, devpathlen);
263	if (sp != NULL)
264		kmem_free(sp, sizeof (*sp));
265	return (NULL);
266}
267
268/*
269 * Initialize the STREAMS device aspect of the sockparams entry.
270 */
271static int
272sockparams_sdev_init(struct sockparams *sp, char *devpath, int devpathlen)
273{
274	vnode_t *vp = NULL;
275	int error;
276
277	ASSERT(devpath != NULL);
278
279	if ((error = sogetvp(devpath, &vp, UIO_SYSSPACE)) != 0) {
280		dprint(0, ("sockparams_sdev_init: vp %s failed with %d\n",
281		    devpath, error));
282		return (error);
283	}
284
285	ASSERT(vp != NULL);
286	sp->sp_sdev_info.sd_vnode = vp;
287	sp->sp_sdev_info.sd_devpath = devpath;
288	sp->sp_sdev_info.sd_devpathlen = devpathlen;
289
290	return (0);
291}
292
293/*
294 * sockparams_destroy(struct sockparams *sp)
295 *
296 * Releases all the resources associated with the sockparams entry,
297 * and frees the sockparams entry.
298 *
299 * Arguments:
300 *   sp: the sockparams entry to destroy.
301 *
302 * Returns:
303 *   Nothing.
304 *
305 * Locking:
306 *   The sp_lock of the entry can not be held.
307 */
308void
309sockparams_destroy(struct sockparams *sp)
310{
311	ASSERT(sp->sp_refcnt == 0);
312	ASSERT(!list_link_active(&sp->sp_node));
313
314	sockparams_sdev_fini(sp);
315
316	if (sp->sp_smod_info != NULL)
317		SMOD_DEC_REF(sp->sp_smod_info, sp->sp_smod_name);
318	kmem_free(sp->sp_smod_name, strlen(sp->sp_smod_name) + 1);
319	sp->sp_smod_name = NULL;
320	sp->sp_smod_info = NULL;
321	mutex_destroy(&sp->sp_lock);
322	sockparams_kstat_fini(sp);
323
324	sof_sockparams_fini(sp);
325	list_destroy(&sp->sp_auto_filters);
326	list_destroy(&sp->sp_prog_filters);
327
328	kmem_free(sp, sizeof (*sp));
329}
330
331/*
332 * Clean up the STREAMS device part of the sockparams entry.
333 */
334static void
335sockparams_sdev_fini(struct sockparams *sp)
336{
337	sdev_info_t sd;
338
339	/*
340	 * if the entry does not have a STREAMS device, then there
341	 * is nothing to do.
342	 */
343	if (!SOCKPARAMS_HAS_DEVICE(sp))
344		return;
345
346	sd = sp->sp_sdev_info;
347	if (sd.sd_vnode != NULL)
348		VN_RELE(sd.sd_vnode);
349	if (sd.sd_devpathlen != 0)
350		kmem_free(sd.sd_devpath, sd.sd_devpathlen);
351
352	sp->sp_sdev_info.sd_vnode = NULL;
353	sp->sp_sdev_info.sd_devpath = NULL;
354}
355
356/*
357 * Look for a matching sockparams entry on the given list.
358 * The caller must hold the associated list lock.
359 */
360static struct sockparams *
361sockparams_find(list_t *list, int family, int type, int protocol,
362    boolean_t by_devpath, const char *name)
363{
364	struct sockparams *sp;
365
366	for (sp = list_head(list); sp != NULL; sp = list_next(list, sp)) {
367		if (sp->sp_family == family && sp->sp_type == type) {
368			if (sp->sp_protocol == protocol) {
369				if (name == NULL)
370					break;
371				else if (by_devpath &&
372				    sp->sp_sdev_info.sd_devpath != NULL &&
373				    strcmp(sp->sp_sdev_info.sd_devpath,
374				    name) == 0)
375					break;
376				else if (strcmp(sp->sp_smod_name, name) == 0)
377					break;
378			}
379		}
380	}
381	return (sp);
382}
383
384/*
385 * sockparams_hold_ephemeral()
386 *
387 * Returns an ephemeral sockparams entry of the requested family, type and
388 * protocol. The entry is returned held, and the caller is responsible for
389 * dropping the reference using SOCKPARAMS_DEC_REF() once done.
390 *
391 * All ephemeral entries are on list (sp_ephem_list). If there is an
392 * entry on the list that match the search criteria, then a reference is
393 * placed on that entry. Otherwise, a new entry is created and inserted
394 * in the list. The entry is removed from the list when the last reference
395 * is dropped.
396 *
397 * The tpi flag is used to determine whether name refers to a device or
398 * module name.
399 */
400static struct sockparams *
401sockparams_hold_ephemeral(int family, int type, int protocol,
402    const char *name, boolean_t by_devpath, int kmflag, int *errorp)
403{
404	struct sockparams *sp = NULL;
405	*errorp = 0;
406
407	/*
408	 * First look for an existing entry
409	 */
410	rw_enter(&sockconf_lock, RW_READER);
411	sp = sockparams_find(&sp_ephem_list, family, type, protocol,
412	    by_devpath, name);
413	if (sp != NULL) {
414		SOCKPARAMS_INC_REF(sp);
415		rw_exit(&sockconf_lock);
416		sp_g_stats.spgs_ephem_nreuse.value.ui64++;
417
418		return (sp);
419	} else {
420		struct sockparams *newsp = NULL;
421		char *namebuf = NULL;
422		int namelen = 0;
423
424		rw_exit(&sockconf_lock);
425
426		namelen = strlen(name) + 1;
427		namebuf = kmem_alloc(namelen, kmflag);
428		if (namebuf == NULL) {
429			*errorp = ENOMEM;
430			return (NULL);
431		}
432
433		(void *)strncpy(namebuf, name, namelen);
434		if (by_devpath) {
435			newsp = sockparams_create(family, type,
436			    protocol, NULL, namebuf, namelen,
437			    SOCKPARAMS_EPHEMERAL, kmflag, errorp);
438		} else {
439			newsp = sockparams_create(family, type,
440			    protocol, namebuf, NULL, 0,
441			    SOCKPARAMS_EPHEMERAL, kmflag, errorp);
442		}
443
444		if (newsp == NULL) {
445			ASSERT(*errorp != 0);
446			return (NULL);
447		}
448
449		/*
450		 * Time to load the socket module.
451		 */
452		ASSERT(newsp->sp_smod_info == NULL);
453		newsp->sp_smod_info =
454		    smod_lookup_byname(newsp->sp_smod_name);
455		if (newsp->sp_smod_info == NULL) {
456			/* Failed to load */
457			sockparams_destroy(newsp);
458			*errorp = ENXIO;
459			return (NULL);
460		}
461
462		/*
463		 * The sockparams entry was created, now try to add it
464		 * to the list. We need to hold the lock as a WRITER.
465		 */
466		rw_enter(&sockconf_lock, RW_WRITER);
467		sp = sockparams_find(&sp_ephem_list, family, type, protocol,
468		    by_devpath, name);
469		if (sp != NULL) {
470			/*
471			 * Someone has requested a matching entry, so just
472			 * place a hold on it and release the entry we alloc'ed.
473			 */
474			SOCKPARAMS_INC_REF(sp);
475			rw_exit(&sockconf_lock);
476
477			sockparams_destroy(newsp);
478		} else {
479			*errorp = sof_sockparams_init(newsp);
480			if (*errorp != 0) {
481				rw_exit(&sockconf_lock);
482				sockparams_destroy(newsp);
483				return (NULL);
484			}
485			SOCKPARAMS_INC_REF(newsp);
486			list_insert_tail(&sp_ephem_list, newsp);
487			rw_exit(&sockconf_lock);
488
489			sp = newsp;
490		}
491		ASSERT(*errorp == 0);
492
493		return (sp);
494	}
495}
496
497struct sockparams *
498sockparams_hold_ephemeral_bydev(int family, int type, int protocol,
499    const char *dev, int kmflag, int *errorp)
500{
501	return (sockparams_hold_ephemeral(family, type, protocol, dev, B_TRUE,
502	    kmflag, errorp));
503}
504
505struct sockparams *
506sockparams_hold_ephemeral_bymod(int family, int type, int protocol,
507    const char *mod, int kmflag, int *errorp)
508{
509	return (sockparams_hold_ephemeral(family, type, protocol, mod, B_FALSE,
510	    kmflag, errorp));
511}
512
513/*
514 * Called when the last socket using the ephemeral entry is dropping
515 * its' reference. To maintain lock order we must drop the sockparams
516 * lock before calling this function. As a result, a new reference
517 * might be placed on the entry, in which case there is nothing to
518 * do. However, if ref count goes to zero, we delete the entry.
519 */
520void
521sockparams_ephemeral_drop_last_ref(struct sockparams *sp)
522{
523	ASSERT(sp->sp_flags & SOCKPARAMS_EPHEMERAL);
524	ASSERT(MUTEX_NOT_HELD(&sp->sp_lock));
525
526	rw_enter(&sockconf_lock, RW_WRITER);
527	mutex_enter(&sp->sp_lock);
528
529	if (--sp->sp_refcnt == 0) {
530		list_remove(&sp_ephem_list, sp);
531		mutex_exit(&sp->sp_lock);
532		rw_exit(&sockconf_lock);
533
534		sockparams_destroy(sp);
535	} else {
536		mutex_exit(&sp->sp_lock);
537		rw_exit(&sockconf_lock);
538	}
539}
540
541/*
542 * sockparams_add(struct sockparams *sp)
543 *
544 * Tries to add the given sockparams entry to the global list.
545 *
546 * Arguments:
547 *   sp: the sockparms entry to add
548 *
549 * Returns:
550 *   On success 0, but if an entry already exists, then EEXIST
551 *   is returned.
552 *
553 * Locking:
554 *   The caller can not be holding sockconf_lock.
555 */
556int
557sockparams_add(struct sockparams *sp)
558{
559	int error;
560
561	ASSERT(!(sp->sp_flags & SOCKPARAMS_EPHEMERAL));
562
563	rw_enter(&sockconf_lock, RW_WRITER);
564	if (sockparams_find(&sphead, sp->sp_family, sp->sp_type,
565	    sp->sp_protocol, B_TRUE, NULL) != 0) {
566		rw_exit(&sockconf_lock);
567		return (EEXIST);
568	} else {
569		/*
570		 * Unique sockparams entry, so init the kstats.
571		 */
572		sockparams_kstat_init(sp);
573
574		/*
575		 * Before making the socket type available we must make
576		 * sure that interested socket filters are aware of it.
577		 */
578		error = sof_sockparams_init(sp);
579		if (error != 0) {
580			rw_exit(&sockconf_lock);
581			return (error);
582		}
583		list_insert_tail(&sphead, sp);
584		rw_exit(&sockconf_lock);
585		return (0);
586	}
587}
588
589/*
590 * sockparams_delete(int family, int type, int protocol)
591 *
592 * Marks the sockparams entry for a specific family, type and protocol
593 * for deletion. The entry is removed from the list and destroyed
594 * if no one is holding a reference to it.
595 *
596 * Arguments:
597 *   family, type, protocol: the socket type that should be removed.
598 *
599 * Returns:
600 *   On success 0, otherwise ENXIO.
601 *
602 * Locking:
603 *   Caller can not be holding sockconf_lock or the sp_lock of
604 *   any sockparams entry.
605 */
606int
607sockparams_delete(int family, int type, int protocol)
608{
609	struct sockparams *sp;
610
611	rw_enter(&sockconf_lock, RW_WRITER);
612	sp = sockparams_find(&sphead, family, type, protocol, B_TRUE, NULL);
613
614	if (sp != NULL) {
615		/*
616		 * If no one is holding a reference to the entry, then
617		 * we go ahead and remove it from the list and then
618		 * destroy it.
619		 */
620		mutex_enter(&sp->sp_lock);
621		if (sp->sp_refcnt != 0) {
622			mutex_exit(&sp->sp_lock);
623			rw_exit(&sockconf_lock);
624			return (EBUSY);
625		}
626		mutex_exit(&sp->sp_lock);
627		/* Delete the sockparams entry. */
628		list_remove(&sphead, sp);
629		rw_exit(&sockconf_lock);
630
631		sockparams_destroy(sp);
632		return (0);
633	} else {
634		rw_exit(&sockconf_lock);
635		return (ENXIO);
636	}
637}
638
639
640/*
641 * solookup(int family, int type, int protocol, struct sockparams **spp)
642 *
643 * Lookup an entry in the sockparams list based on the triple. The returned
644 * entry either exactly match the given tuple, or it is the 'default' entry
645 * for the given <family, type>. A default entry is on with a protocol
646 * value of zero.
647 *
648 * Arguments:
649 *   family, type, protocol: tuple to search for
650 *   spp: Value-return argument
651 *
652 * Returns:
653 *   If an entry is found, 0 is returned and *spp is set to point to the
654 *   entry. In case an entry is not found, *spp is set to NULL, and an
655 *   error code is returned. The errors are (in decreasing precedence):
656 *	EAFNOSUPPORT - address family not in list
657 *	EPROTONOSUPPORT - address family supported but not protocol.
658 *	EPROTOTYPE - address family and protocol supported but not socket type.
659 *
660 * TODO: should use ddi_modopen()/ddi_modclose()
661 */
662int
663solookup(int family, int type, int protocol, struct sockparams **spp)
664{
665	struct sockparams *sp = NULL;
666	int error = 0;
667
668	*spp = NULL;
669	rw_enter(&sockconf_lock, RW_READER);
670
671	/*
672	 * Search the sockparams list for an appropiate entry.
673	 * Hopefully we find an entry that match the exact family,
674	 * type and protocol specified by the user, in which case
675	 * we return that entry. However, we also keep track of
676	 * the default entry for a specific family and type, the
677	 * entry of which would have a protocol value of 0.
678	 */
679	sp = sockparams_find(&sphead, family, type, protocol, B_TRUE, NULL);
680
681	if (sp == NULL) {
682		int found = 0;
683
684		/* Determine correct error code */
685		for (sp = list_head(&sphead); sp != NULL;
686		    sp = list_next(&sphead, sp)) {
687			if (sp->sp_family == family && found < 1)
688				found = 1;
689			if (sp->sp_family == family &&
690			    sp->sp_protocol == protocol && found < 2)
691				found = 2;
692		}
693		rw_exit(&sockconf_lock);
694		switch (found) {
695		case 0:
696			error = EAFNOSUPPORT;
697			break;
698		case 1:
699			error = EPROTONOSUPPORT;
700			break;
701		case 2:
702			error = EPROTOTYPE;
703			break;
704		}
705		return (error);
706	}
707
708	/*
709	 * An entry was found.
710	 *
711	 * We put a hold on the entry early on, so if the
712	 * sockmod is not loaded, and we have to exit
713	 * sockconf_lock to call modload(), we know that the
714	 * sockparams entry wont go away. That way we don't
715	 * have to look up the entry once we come back from
716	 * modload().
717	 */
718	SOCKPARAMS_INC_REF(sp);
719	rw_exit(&sockconf_lock);
720
721	if (sp->sp_smod_info == NULL) {
722		smod_info_t *smod = smod_lookup_byname(sp->sp_smod_name);
723
724		if (smod == NULL) {
725			/*
726			 * We put a hold on the sockparams entry
727			 * earlier, hoping everything would work out.
728			 * That obviously did not happen, so release
729			 * the hold here.
730			 */
731			SOCKPARAMS_DEC_REF(sp);
732			/*
733			 * We should probably mark the sockparams as
734			 * "bad", and redo the lookup skipping the
735			 * "bad" entries. I.e., sp->sp_mod_state |= BAD,
736			 * return (solookup(...))
737			 */
738			return (ENXIO);
739		}
740		/*
741		 * Another thread might have already looked up the socket
742		 * module for this entry. In that case we need to drop our
743		 * reference to `smod' to ensure that the sockparams entry
744		 * only holds one reference.
745		 */
746		mutex_enter(&sp->sp_lock);
747		if (sp->sp_smod_info == NULL)
748			sp->sp_smod_info = smod;
749		else
750			SMOD_DEC_REF(smod, sp->sp_smod_name);
751		mutex_exit(&sp->sp_lock);
752	}
753
754	/*
755	 * Alright, we have a valid sockparams entry.
756	 */
757	*spp = sp;
758	return (0);
759}
760
761/*
762 * Called when filter entry `ent' is going away. All sockparams remove
763 * their references to `ent'.
764 */
765static void
766sockparams_filter_cleanup_impl(sof_entry_t *ent, list_t *list)
767{
768	struct sockparams *sp;
769	sp_filter_t *fil;
770	list_t *flist;
771
772	ASSERT(RW_WRITE_HELD(&sockconf_lock));
773
774	for (sp = list_head(list); sp != NULL;
775	    sp = list_next(list, sp)) {
776		flist = (ent->sofe_flags & SOFEF_AUTO) ?
777		    &sp->sp_auto_filters : &sp->sp_prog_filters;
778		for (fil = list_head(flist); fil != NULL;
779		    fil = list_next(flist, fil)) {
780			if (fil->spf_filter == ent) {
781				list_remove(flist, fil);
782				kmem_free(fil, sizeof (sp_filter_t));
783				break;
784			}
785		}
786	}
787}
788void
789sockparams_filter_cleanup(sof_entry_t *ent)
790{
791	sockparams_filter_cleanup_impl(ent, &sphead);
792	sockparams_filter_cleanup_impl(ent, &sp_ephem_list);
793}
794
795/*
796 * New filter is being added; walk the list of sockparams to see if
797 * the filter is interested in any of the sockparams.
798 */
799static int
800sockparams_new_filter_impl(sof_entry_t *ent, list_t *list)
801{
802	struct sockparams *sp;
803	int err;
804
805	ASSERT(RW_WRITE_HELD(&sockconf_lock));
806
807	for (sp = list_head(list); sp != NULL;
808	    sp = list_next(list, sp)) {
809		if ((err = sof_entry_proc_sockparams(ent, sp)) != 0) {
810			sockparams_filter_cleanup(ent);
811			return (err);
812		}
813	}
814	return (0);
815}
816
817int
818sockparams_new_filter(sof_entry_t *ent)
819{
820	int error;
821
822	if ((error = sockparams_new_filter_impl(ent, &sphead)) != 0)
823		return (error);
824
825	if ((error = sockparams_new_filter_impl(ent, &sp_ephem_list)) != 0)
826		sockparams_filter_cleanup_impl(ent, &sphead);
827	return (error);
828}
829
830/*
831 * Setup and return socket configuration table.
832 */
833int
834sockparams_copyout_socktable(uintptr_t socktable)
835{
836	STRUCT_DECL(sockconfig_socktable, st);
837	struct sockparams *sp;
838	uint_t count;
839	uint_t i = 0;
840	int ret = 0;
841	sockconfig_socktable_entry_t *se;
842
843	STRUCT_INIT(st, get_udatamodel());
844	if (ddi_copyin((void *)socktable, STRUCT_BUF(st),
845	    STRUCT_SIZE(st), 0) != 0)
846		return (EFAULT);
847
848	rw_enter(&sockconf_lock, RW_READER);
849
850	count = STRUCT_FGET(st, num_of_entries);
851	/*
852	 * If the output buffer is size zero, just copy out the count.
853	 */
854	if (count == 0) {
855		for (sp = list_head(&sphead); sp != NULL;
856		    sp = list_next(&sphead, sp)) {
857			count++;
858		}
859		STRUCT_FSET(st, num_of_entries, count);
860
861		rw_exit(&sockconf_lock);
862		if (ddi_copyout(STRUCT_BUF(st), (void *)socktable,
863		    STRUCT_SIZE(st), 0) != 0)
864			return (EFAULT);
865
866		return (0);
867	}
868
869	se = kmem_alloc(count * sizeof (sockconfig_socktable_entry_t),
870	    KM_SLEEP);
871	for (sp = list_head(&sphead); sp != NULL;
872	    sp = list_next(&sphead, sp)) {
873		if (i >= count) {
874			/*
875			 * Return if the number of entries has changed.
876			 */
877			rw_exit(&sockconf_lock);
878			kmem_free(se,
879			    count * sizeof (sockconfig_socktable_entry_t));
880			return (EAGAIN);
881		}
882		se[i].se_family = sp->sp_family;
883		se[i].se_type = sp->sp_type;
884		se[i].se_protocol = sp->sp_protocol;
885		(void) strncpy(se[i].se_modname, sp->sp_smod_name,
886		    MODMAXNAMELEN);
887		if (sp->sp_sdev_info.sd_devpath != NULL)
888			(void) strncpy(se[i].se_strdev,
889			    sp->sp_sdev_info.sd_devpath, MAXPATHLEN);
890		se[i].se_refcnt = sp->sp_refcnt;
891		se[i].se_flags = sp->sp_flags;
892		i++;
893	}
894	rw_exit(&sockconf_lock);
895	if (ddi_copyout(se, STRUCT_FGETP(st, st_entries),
896	    i * sizeof (sockconfig_socktable_entry_t), 0) != 0)
897		ret = EFAULT;
898
899	STRUCT_FSET(st, num_of_entries, i);
900	kmem_free(se, count * sizeof (sockconfig_socktable_entry_t));
901
902	if (ddi_copyout(STRUCT_BUF(st), (void *)socktable,
903	    STRUCT_SIZE(st), 0) != 0)
904		ret = EFAULT;
905
906	return (ret);
907}
908