xref: /titanic_41/usr/src/uts/common/os/damap.c (revision 0b42f15ac52b077791d4ba079e8c163c592c3fda)
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) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
24  */
25 
26 #include <sys/note.h>
27 #include <sys/types.h>
28 #include <sys/param.h>
29 #include <sys/systm.h>
30 #include <sys/buf.h>
31 #include <sys/kmem.h>
32 #include <sys/cmn_err.h>
33 #include <sys/debug.h>
34 #include <sys/sunndi.h>
35 #include <sys/kstat.h>
36 #include <sys/conf.h>
37 #include <sys/ddi_periodic.h>
38 #include <sys/devctl.h>
39 #include <sys/callb.h>
40 #include <sys/sysevent.h>
41 #include <sys/taskq.h>
42 #include <sys/ddi.h>
43 #include <sys/bitset.h>
44 #include <sys/damap.h>
45 #include <sys/damap_impl.h>
46 
47 #ifdef DEBUG
48 static int damap_debug = 0;
49 #endif /* DEBUG */
50 
51 extern taskq_t *system_taskq;
52 
53 static void dam_addrset_activate(dam_t *, bitset_t *);
54 static void dam_addrset_deactivate(dam_t *, bitset_t *);
55 static void dam_stabilize_map(void *);
56 static void dam_addr_stable_cb(void *);
57 static void dam_addrset_stable_cb(void *);
58 static void dam_sched_timeout(void (*timeout_cb)(), dam_t *, clock_t);
59 static void dam_addr_report(dam_t *, dam_da_t *, id_t, int);
60 static void dam_addr_release(dam_t *, id_t);
61 static void dam_addr_report_release(dam_t *, id_t);
62 static void dam_addr_deactivate(dam_t *, id_t);
63 static void dam_deact_cleanup(dam_t *, id_t, char *, damap_deact_rsn_t);
64 static id_t dam_get_addrid(dam_t *, char *);
65 static int dam_kstat_create(dam_t *);
66 static int dam_map_alloc(dam_t *);
67 
68 #define	DAM_INCR_STAT(mapp, stat)				\
69 	if ((mapp)->dam_kstatsp) {				\
70 		struct dam_kstats *stp = (mapp)->dam_kstatsp->ks_data;	\
71 		stp->stat.value.ui32++;				\
72 	}
73 
74 #define	DAM_SET_STAT(mapp, stat, val)				\
75 	if ((mapp)->dam_kstatsp) {				\
76 		struct dam_kstats *stp = (mapp)->dam_kstatsp->ks_data;	\
77 		stp->stat.value.ui32 = (val);			\
78 	}
79 
80 
81 /*
82  * increase damap size by 64 entries at a time
83  */
84 #define	DAM_SIZE_BUMP	64
85 
86 int	damap_taskq_dispatch_retry_usec = 1000;
87 
88 /*
89  * config/unconfig taskq data
90  */
91 typedef struct {
92 	dam_t *tqd_mapp;
93 	id_t tqd_id;
94 } cfg_tqd_t;
95 
96 extern pri_t maxclsyspri;
97 
98 /*
99  * Create new device address map
100  *
101  * name:		map name (kstat unique)
102  * size:		max # of map entries
103  * mode:		style of address reports: per-address or fullset
104  * stable_usec:		# of quiescent microseconds before report/map is stable
105  *
106  * activate_arg:	address provider activation-callout private
107  * activate_cb:		address provider activation callback handler
108  * deactivate_cb:	address provider deactivation callback handler
109  *
110  * config_arg:		configuration-callout private
111  * config_cb:		class configuration callout
112  * unconfig_cb:		class unconfiguration callout
113  *
114  * damapp:		pointer to map handle (return)
115  *
116  * Returns:	DAM_SUCCESS
117  *		DAM_EINVAL	Invalid argument(s)
118  *		DAM_FAILURE	General failure
119  */
120 int
damap_create(char * name,damap_rptmode_t mode,int map_opts,int stable_usec,void * activate_arg,damap_activate_cb_t activate_cb,damap_deactivate_cb_t deactivate_cb,void * config_arg,damap_configure_cb_t configure_cb,damap_unconfig_cb_t unconfig_cb,damap_t ** damapp)121 damap_create(char *name, damap_rptmode_t mode, int map_opts,
122     int stable_usec, void *activate_arg, damap_activate_cb_t activate_cb,
123     damap_deactivate_cb_t deactivate_cb,
124     void *config_arg, damap_configure_cb_t configure_cb,
125     damap_unconfig_cb_t unconfig_cb,
126     damap_t **damapp)
127 {
128 	dam_t *mapp;
129 
130 	if (configure_cb == NULL || unconfig_cb == NULL || name == NULL)
131 		return (DAM_EINVAL);
132 
133 	mapp = kmem_zalloc(sizeof (*mapp), KM_SLEEP);
134 	mapp->dam_options = map_opts;
135 	mapp->dam_stable_ticks = drv_usectohz(stable_usec);
136 	mapp->dam_size = 0;
137 	mapp->dam_rptmode = mode;
138 	mapp->dam_activate_arg = activate_arg;
139 	mapp->dam_activate_cb = (activate_cb_t)activate_cb;
140 	mapp->dam_deactivate_cb = (deactivate_cb_t)deactivate_cb;
141 	mapp->dam_config_arg = config_arg;
142 	mapp->dam_configure_cb = (configure_cb_t)configure_cb;
143 	mapp->dam_unconfig_cb = (unconfig_cb_t)unconfig_cb;
144 	mapp->dam_name = i_ddi_strdup(name, KM_SLEEP);
145 	mutex_init(&mapp->dam_lock, NULL, MUTEX_DRIVER, NULL);
146 	cv_init(&mapp->dam_sync_cv, NULL, CV_DRIVER, NULL);
147 	bitset_init(&mapp->dam_active_set);
148 	bitset_init(&mapp->dam_stable_set);
149 	bitset_init(&mapp->dam_report_set);
150 	*damapp = (damap_t *)mapp;
151 
152 	DTRACE_PROBE5(damap__create,
153 	    char *, mapp->dam_name, damap_t *, mapp,
154 	    damap_rptmode_t, mode, int, map_opts, int, stable_usec);
155 
156 	return (DAM_SUCCESS);
157 }
158 
159 /*
160  * Allocate backing resources
161  *
162  * DAMs are lightly backed on create - major allocations occur
163  * at the time a report is made to the map, and are extended on
164  * a demand basis.
165  */
166 static int
dam_map_alloc(dam_t * mapp)167 dam_map_alloc(dam_t *mapp)
168 {
169 	void *softstate_p;
170 
171 	ASSERT(mutex_owned(&mapp->dam_lock));
172 	if (mapp->dam_flags & DAM_DESTROYPEND)
173 		return (DAM_FAILURE);
174 
175 	/*
176 	 * dam_high > 0 signals map allocation complete
177 	 */
178 	if (mapp->dam_high)
179 		return (DAM_SUCCESS);
180 
181 	mapp->dam_size = DAM_SIZE_BUMP;
182 	if (ddi_soft_state_init(&softstate_p, sizeof (dam_da_t),
183 	    mapp->dam_size) != DDI_SUCCESS)
184 		return (DAM_FAILURE);
185 
186 	if (ddi_strid_init(&mapp->dam_addr_hash, mapp->dam_size) !=
187 	    DDI_SUCCESS) {
188 		ddi_soft_state_fini(softstate_p);
189 		return (DAM_FAILURE);
190 	}
191 	if (dam_kstat_create(mapp) != DDI_SUCCESS) {
192 		ddi_soft_state_fini(softstate_p);
193 		ddi_strid_fini(&mapp->dam_addr_hash);
194 		return (DAM_FAILURE);
195 	}
196 	mapp->dam_da = softstate_p;
197 	mapp->dam_high = 1;
198 	bitset_resize(&mapp->dam_active_set, mapp->dam_size);
199 	bitset_resize(&mapp->dam_stable_set, mapp->dam_size);
200 	bitset_resize(&mapp->dam_report_set, mapp->dam_size);
201 	return (DAM_SUCCESS);
202 }
203 
204 /*
205  * Destroy address map
206  *
207  * damapp:	address map
208  *
209  * Returns:	DAM_SUCCESS
210  *		DAM_EINVAL	Invalid argument(s)
211  *		DAM_FAILURE	General failure
212  */
213 void
damap_destroy(damap_t * damapp)214 damap_destroy(damap_t *damapp)
215 {
216 	int i;
217 	dam_t *mapp = (dam_t *)damapp;
218 
219 	ASSERT(mapp);
220 
221 	DTRACE_PROBE2(damap__destroy,
222 	    char *, mapp->dam_name, damap_t *, mapp);
223 
224 	mutex_enter(&mapp->dam_lock);
225 
226 	/*
227 	 * prevent new reports from being added to the map
228 	 */
229 	mapp->dam_flags |= DAM_DESTROYPEND;
230 
231 	if (mapp->dam_high) {
232 		mutex_exit(&mapp->dam_lock);
233 		/*
234 		 * wait for outstanding reports to stabilize and cancel
235 		 * the timer for this map
236 		 */
237 		(void) damap_sync(damapp, 0);
238 		mutex_enter(&mapp->dam_lock);
239 		dam_sched_timeout(NULL, mapp, 0);
240 
241 		/*
242 		 * map is at full stop
243 		 * release the contents of the map, invoking the
244 		 * detactivation protocol as addresses are released
245 		 */
246 		mutex_exit(&mapp->dam_lock);
247 		for (i = 1; i < mapp->dam_high; i++) {
248 			if (ddi_get_soft_state(mapp->dam_da, i) == NULL)
249 				continue;
250 
251 			ASSERT(DAM_IN_REPORT(mapp, i) == 0);
252 
253 			if (DAM_IS_STABLE(mapp, i)) {
254 				dam_addr_deactivate(mapp, i);
255 			} else {
256 				ddi_strid_free(mapp->dam_addr_hash, i);
257 				ddi_soft_state_free(mapp->dam_da, i);
258 			}
259 		}
260 		ddi_strid_fini(&mapp->dam_addr_hash);
261 		ddi_soft_state_fini(&mapp->dam_da);
262 		kstat_delete(mapp->dam_kstatsp);
263 	} else
264 		mutex_exit(&mapp->dam_lock);
265 
266 	bitset_fini(&mapp->dam_active_set);
267 	bitset_fini(&mapp->dam_stable_set);
268 	bitset_fini(&mapp->dam_report_set);
269 	mutex_destroy(&mapp->dam_lock);
270 	cv_destroy(&mapp->dam_sync_cv);
271 	if (mapp->dam_name)
272 		kmem_free(mapp->dam_name, strlen(mapp->dam_name) + 1);
273 	kmem_free(mapp, sizeof (*mapp));
274 }
275 
276 /*
277  * Wait for map stability.  If sync was successfull then return 1.
278  * If called with a non-zero sync_usec, then a return value of 0 means a
279  * timeout occurred prior to sync completion. NOTE: if sync_usec is
280  * non-zero, it should be much longer than dam_stable_ticks.
281  *
282  * damapp:	address map
283  * sync_usec:	micorseconds until we give up on sync completion.
284  */
285 #define	WAITFOR_FLAGS (DAM_SETADD | DAM_SPEND)
286 int
damap_sync(damap_t * damapp,int sync_usec)287 damap_sync(damap_t *damapp, int sync_usec)
288 {
289 	dam_t	*mapp = (dam_t *)damapp;
290 	int	rv;
291 
292 	ASSERT(mapp);
293 	DTRACE_PROBE3(damap__map__sync__start,
294 	    char *, mapp->dam_name, dam_t *, mapp,
295 	    int, sync_usec);
296 
297 	/*
298 	 * Block when waiting for
299 	 *	a) stabilization pending or a fullset update pending
300 	 *	b) the report set to finalize (bitset is null)
301 	 *	c) any scheduled timeouts to fire
302 	 */
303 	rv = 1;					/* return synced */
304 	mutex_enter(&mapp->dam_lock);
305 again:	while ((mapp->dam_flags & WAITFOR_FLAGS) ||
306 	    (!bitset_is_null(&mapp->dam_report_set)) ||
307 	    (mapp->dam_tid != 0)) {
308 		DTRACE_PROBE2(damap__map__sync__waiting,
309 		    char *, mapp->dam_name, dam_t *, mapp);
310 
311 		/* Wait for condition relayed via timeout */
312 		if (sync_usec) {
313 			if (cv_reltimedwait(&mapp->dam_sync_cv, &mapp->dam_lock,
314 			    drv_usectohz(sync_usec), TR_MICROSEC) == -1) {
315 				mapp->dam_sync_to_cnt++;
316 				rv = 0;		/* return timeout */
317 				break;
318 			}
319 		} else
320 			cv_wait(&mapp->dam_sync_cv, &mapp->dam_lock);
321 	}
322 
323 	if (rv) {
324 		/*
325 		 * Delay one stabilization time after the apparent sync above
326 		 * and verify accuracy - resync if not accurate.
327 		 */
328 		(void) cv_reltimedwait(&mapp->dam_sync_cv, &mapp->dam_lock,
329 		    mapp->dam_stable_ticks, TR_MICROSEC);
330 		if (rv && ((mapp->dam_flags & WAITFOR_FLAGS) ||
331 		    (!bitset_is_null(&mapp->dam_report_set)) ||
332 		    (mapp->dam_tid != 0)))
333 			goto again;
334 	}
335 	mutex_exit(&mapp->dam_lock);
336 
337 	DTRACE_PROBE3(damap__map__sync__end,
338 	    char *, mapp->dam_name, dam_t *, mapp,
339 	    int, rv);
340 	return (rv);
341 }
342 
343 /*
344  * Return 1 if active set is empty
345  */
346 int
damap_is_empty(damap_t * damapp)347 damap_is_empty(damap_t *damapp)
348 {
349 	dam_t	*mapp = (dam_t *)damapp;
350 	int	rv;
351 
352 	mutex_enter(&mapp->dam_lock);
353 	rv = bitset_is_null(&mapp->dam_active_set);
354 	mutex_exit(&mapp->dam_lock);
355 	return (rv);
356 }
357 
358 /*
359  * Get the name of a device address map
360  *
361  * damapp:	address map
362  *
363  * Returns:	name
364  */
365 char *
damap_name(damap_t * damapp)366 damap_name(damap_t *damapp)
367 {
368 	dam_t *mapp = (dam_t *)damapp;
369 
370 	return (mapp ? mapp->dam_name : "UNKNOWN_damap");
371 }
372 
373 /*
374  * Get the current size of the device address map
375  *
376  * damapp:	address map
377  *
378  * Returns:	size
379  */
380 int
damap_size(damap_t * damapp)381 damap_size(damap_t *damapp)
382 {
383 	dam_t *mapp = (dam_t *)damapp;
384 
385 	return (mapp->dam_size);
386 }
387 
388 /*
389  * Report an address to per-address report
390  *
391  * damapp:	address map handle
392  * address:	address in ascii string representation
393  * addridp:	address ID
394  * nvl:		optional nvlist of configuration-private data
395  * addr_priv:	optional provider-private (passed to activate/deactivate cb)
396  *
397  * Returns:	DAM_SUCCESS
398  *		DAM_EINVAL	Invalid argument(s)
399  *		DAM_MAPFULL	address map exhausted
400  */
401 int
damap_addr_add(damap_t * damapp,char * address,damap_id_t * addridp,nvlist_t * nvl,void * addr_priv)402 damap_addr_add(damap_t *damapp, char *address, damap_id_t *addridp,
403     nvlist_t *nvl, void *addr_priv)
404 {
405 	dam_t *mapp = (dam_t *)damapp;
406 	id_t addrid;
407 	dam_da_t *passp;
408 
409 	if (!mapp || !address || (mapp->dam_rptmode != DAMAP_REPORT_PERADDR))
410 		return (DAM_EINVAL);
411 
412 	DTRACE_PROBE3(damap__addr__add,
413 	    char *, mapp->dam_name, dam_t *, mapp,
414 	    char *, address);
415 
416 	mutex_enter(&mapp->dam_lock);
417 	if ((dam_map_alloc(mapp) != DAM_SUCCESS) ||
418 	    ((addrid = dam_get_addrid(mapp, address)) == 0)) {
419 		mutex_exit(&mapp->dam_lock);
420 		return (DAM_MAPFULL);
421 	}
422 
423 	passp = ddi_get_soft_state(mapp->dam_da, addrid);
424 	ASSERT(passp != NULL);
425 
426 	/*
427 	 * If re-reporting the same address (add or remove) clear
428 	 * the existing report
429 	 */
430 	if (DAM_IN_REPORT(mapp, addrid)) {
431 		DTRACE_PROBE3(damap__addr__add__jitter,
432 		    char *, mapp->dam_name, dam_t *, mapp,
433 		    char *, address);
434 		DAM_INCR_STAT(mapp, dam_jitter);
435 		dam_addr_report_release(mapp, addrid);
436 		passp->da_jitter++;
437 	}
438 	passp->da_ppriv_rpt = addr_priv;
439 	if (nvl)
440 		(void) nvlist_dup(nvl, &passp->da_nvl_rpt, KM_SLEEP);
441 
442 	dam_addr_report(mapp, passp, addrid, RPT_ADDR_ADD);
443 	if (addridp != NULL)
444 		*addridp = (damap_id_t)addrid;
445 	mutex_exit(&mapp->dam_lock);
446 	return (DAM_SUCCESS);
447 }
448 
449 /*
450  * Report removal of address from per-address report
451  *
452  * damapp:	address map
453  * address:	address in ascii string representation
454  *
455  * Returns:	DAM_SUCCESS
456  *		DAM_EINVAL	Invalid argument(s)
457  *		DAM_FAILURE	General failure
458  */
459 int
damap_addr_del(damap_t * damapp,char * address)460 damap_addr_del(damap_t *damapp, char *address)
461 {
462 	dam_t *mapp = (dam_t *)damapp;
463 	id_t addrid;
464 	dam_da_t *passp;
465 
466 	if (!mapp || !address || (mapp->dam_rptmode != DAMAP_REPORT_PERADDR))
467 		return (DAM_EINVAL);
468 
469 	DTRACE_PROBE3(damap__addr__del,
470 	    char *, mapp->dam_name, dam_t *, mapp,
471 	    char *, address);
472 	mutex_enter(&mapp->dam_lock);
473 	if (dam_map_alloc(mapp) != DAM_SUCCESS) {
474 		mutex_exit(&mapp->dam_lock);
475 		return (DAM_MAPFULL);
476 	}
477 
478 	/*
479 	 * if reporting the removal of an address which is not in the map
480 	 * return success
481 	 */
482 	if (!(addrid = ddi_strid_str2id(mapp->dam_addr_hash, address))) {
483 		mutex_exit(&mapp->dam_lock);
484 		return (DAM_SUCCESS);
485 	}
486 	passp = ddi_get_soft_state(mapp->dam_da, addrid);
487 	ASSERT(passp);
488 	if (DAM_IN_REPORT(mapp, addrid)) {
489 		DTRACE_PROBE3(damap__addr__del__jitter,
490 		    char *, mapp->dam_name, dam_t *, mapp,
491 		    char *, address);
492 		DAM_INCR_STAT(mapp, dam_jitter);
493 		dam_addr_report_release(mapp, addrid);
494 		passp->da_jitter++;
495 	}
496 	dam_addr_report(mapp, passp, addrid, RPT_ADDR_DEL);
497 	mutex_exit(&mapp->dam_lock);
498 	return (DAM_SUCCESS);
499 }
500 
501 static int
damap_addrset_flush_locked(damap_t * damapp)502 damap_addrset_flush_locked(damap_t *damapp)
503 {
504 	dam_t	*mapp = (dam_t *)damapp;
505 	int	idx;
506 
507 	ASSERT(mapp);
508 	ASSERT(mutex_owned(&mapp->dam_lock));
509 	if (mapp->dam_rptmode != DAMAP_REPORT_FULLSET) {
510 		return (DAM_EINVAL);
511 	}
512 
513 	DTRACE_PROBE2(damap__addrset__flush__locked__enter,
514 	    char *, mapp->dam_name, dam_t *, mapp);
515 	if (mapp->dam_flags & DAM_SETADD) {
516 		DTRACE_PROBE2(damap__addrset__flush__locked__reset,
517 		    char *, mapp->dam_name, dam_t *, mapp);
518 
519 		/*
520 		 * cancel stabilization timeout
521 		 */
522 		dam_sched_timeout(NULL, mapp, 0);
523 		DAM_INCR_STAT(mapp, dam_jitter);
524 
525 		/*
526 		 * clear pending reports
527 		 */
528 		for (idx = 1; idx < mapp->dam_high; idx++) {
529 			if (DAM_IN_REPORT(mapp, idx)) {
530 				dam_addr_report_release(mapp, idx);
531 			}
532 		}
533 
534 		bitset_zero(&mapp->dam_report_set);
535 		mapp->dam_flags &= ~DAM_SETADD;
536 		cv_signal(&mapp->dam_sync_cv);
537 	}
538 
539 	return (DAM_SUCCESS);
540 }
541 
542 /*
543  * Initiate full-set report
544  *
545  * damapp:	address map
546  *
547  * Returns:	DAM_SUCCESS
548  *		DAM_EINVAL	Invalid argument(s)
549  */
550 int
damap_addrset_begin(damap_t * damapp)551 damap_addrset_begin(damap_t *damapp)
552 {
553 	dam_t	*mapp = (dam_t *)damapp;
554 	int	rv;
555 
556 	if (mapp == NULL) {
557 		return (DAM_EINVAL);
558 	}
559 
560 	DTRACE_PROBE2(damap__addrset__begin,
561 	    char *, mapp->dam_name, dam_t *, mapp);
562 
563 	mutex_enter(&mapp->dam_lock);
564 	if (dam_map_alloc(mapp) != DAM_SUCCESS) {
565 		mutex_exit(&mapp->dam_lock);
566 
567 		return (DAM_MAPFULL);
568 	}
569 
570 	rv = damap_addrset_flush_locked(damapp);
571 	if (rv == DAM_SUCCESS) {
572 		mapp->dam_flags |= DAM_SETADD;
573 	}
574 	mutex_exit(&mapp->dam_lock);
575 
576 	return (rv);
577 }
578 
579 /*
580  * Cancel full-set report
581  *
582  * damapp:	address map
583  *
584  * Returns:	DAM_SUCCESS
585  *		DAM_EINVAL	Invalid argument(s)
586  */
587 int
damap_addrset_flush(damap_t * damapp)588 damap_addrset_flush(damap_t *damapp)
589 {
590 	int	rv;
591 	dam_t	*mapp = (dam_t *)damapp;
592 
593 	if (mapp == NULL) {
594 		return (DAM_EINVAL);
595 	}
596 
597 	DTRACE_PROBE2(damap__addrset__flush,
598 	    char *, mapp->dam_name, dam_t *, mapp);
599 
600 	mutex_enter(&mapp->dam_lock);
601 	rv = damap_addrset_flush_locked(damapp);
602 	mutex_exit(&mapp->dam_lock);
603 
604 	return (rv);
605 }
606 
607 /*
608  * Report address to full-set report
609  *
610  * damapp:	address map handle
611  * address:	address in ascii string representation
612  * rindx:	index if address stabilizes
613  * nvl:		optional nvlist of configuration-private data
614  * addr_priv:	optional provider-private data (passed to activate/release cb)
615  *
616  * Returns:	DAM_SUCCESS
617  *		DAM_EINVAL	Invalid argument(s)
618  *		DAM_MAPFULL	address map exhausted
619  *		DAM_FAILURE	General failure
620  */
621 int
damap_addrset_add(damap_t * damapp,char * address,damap_id_t * ridx,nvlist_t * nvl,void * addr_priv)622 damap_addrset_add(damap_t *damapp, char *address, damap_id_t *ridx,
623     nvlist_t *nvl, void *addr_priv)
624 {
625 	dam_t *mapp = (dam_t *)damapp;
626 	id_t addrid;
627 	dam_da_t *passp;
628 
629 	if (!mapp || !address || (mapp->dam_rptmode != DAMAP_REPORT_FULLSET))
630 		return (DAM_EINVAL);
631 
632 	DTRACE_PROBE3(damap__addrset__add,
633 	    char *, mapp->dam_name, dam_t *, mapp, char *, address);
634 
635 	mutex_enter(&mapp->dam_lock);
636 	if (!(mapp->dam_flags & DAM_SETADD)) {
637 		mutex_exit(&mapp->dam_lock);
638 		return (DAM_FAILURE);
639 	}
640 
641 	if ((addrid = dam_get_addrid(mapp, address)) == 0) {
642 		mutex_exit(&mapp->dam_lock);
643 		return (DAM_MAPFULL);
644 	}
645 
646 	passp = ddi_get_soft_state(mapp->dam_da, addrid);
647 	ASSERT(passp);
648 	if (DAM_IN_REPORT(mapp, addrid)) {
649 		DTRACE_PROBE3(damap__addrset__add__jitter,
650 		    char *, mapp->dam_name, dam_t *, mapp,
651 		    char *, address);
652 		dam_addr_report_release(mapp, addrid);
653 		passp->da_jitter++;
654 	}
655 	passp->da_ppriv_rpt = addr_priv;
656 	if (nvl)
657 		(void) nvlist_dup(nvl, &passp->da_nvl_rpt, KM_SLEEP);
658 	bitset_add(&mapp->dam_report_set, addrid);
659 	if (ridx)
660 		*ridx = (damap_id_t)addrid;
661 	mutex_exit(&mapp->dam_lock);
662 	return (DAM_SUCCESS);
663 }
664 
665 /*
666  * Commit full-set report for stabilization
667  *
668  * damapp:	address map handle
669  * flags:	(currently 0)
670  *
671  * Returns:	DAM_SUCCESS
672  *		DAM_EINVAL	Invalid argument(s)
673  *		DAM_FAILURE	General failure
674  */
675 int
damap_addrset_end(damap_t * damapp,int flags)676 damap_addrset_end(damap_t *damapp, int flags)
677 {
678 	dam_t *mapp = (dam_t *)damapp;
679 	int i;
680 
681 	if (!mapp || (mapp->dam_rptmode != DAMAP_REPORT_FULLSET))
682 		return (DAM_EINVAL);
683 
684 	DTRACE_PROBE2(damap__addrset__end,
685 	    char *, mapp->dam_name, dam_t *, mapp);
686 
687 	mutex_enter(&mapp->dam_lock);
688 	if (!(mapp->dam_flags & DAM_SETADD)) {
689 		mutex_exit(&mapp->dam_lock);
690 		return (DAM_FAILURE);
691 	}
692 
693 	if (flags & DAMAP_END_RESET) {
694 		DTRACE_PROBE2(damap__addrset__end__reset,
695 		    char *, mapp->dam_name, dam_t *, mapp);
696 		dam_sched_timeout(NULL, mapp, 0);
697 		for (i = 1; i < mapp->dam_high; i++)
698 			if (DAM_IN_REPORT(mapp, i))
699 				dam_addr_report_release(mapp, i);
700 	} else {
701 		mapp->dam_last_update = gethrtime();
702 		dam_sched_timeout(dam_addrset_stable_cb, mapp,
703 		    mapp->dam_stable_ticks);
704 	}
705 	mutex_exit(&mapp->dam_lock);
706 	return (DAM_SUCCESS);
707 }
708 
709 /*
710  * Return nvlist registered with reported address
711  *
712  * damapp:	address map handle
713  * addrid:	address ID
714  *
715  * Returns:	nvlist_t *	provider supplied via damap_addr{set}_add())
716  *		NULL
717  */
718 nvlist_t *
damap_id2nvlist(damap_t * damapp,damap_id_t addrid)719 damap_id2nvlist(damap_t *damapp, damap_id_t addrid)
720 {
721 	dam_t *mapp = (dam_t *)damapp;
722 	dam_da_t *pass;
723 
724 	if (mapp->dam_high && ddi_strid_id2str(mapp->dam_addr_hash, addrid)) {
725 		if (pass = ddi_get_soft_state(mapp->dam_da, addrid))
726 			return (pass->da_nvl);
727 	}
728 	return (NULL);
729 }
730 
731 /*
732  * Return address string
733  *
734  * damapp:	address map handle
735  * addrid:	address ID
736  *
737  * Returns:	char *		Address string
738  *		NULL
739  */
740 char *
damap_id2addr(damap_t * damapp,damap_id_t addrid)741 damap_id2addr(damap_t *damapp, damap_id_t addrid)
742 {
743 	dam_t *mapp = (dam_t *)damapp;
744 
745 	if (mapp->dam_high)
746 		return (ddi_strid_id2str(mapp->dam_addr_hash, addrid));
747 	else
748 		return (NULL);
749 }
750 
751 /*
752  * Release address reference in map
753  *
754  * damapp:	address map handle
755  * addrid:	address ID
756  */
757 void
damap_id_rele(damap_t * damapp,damap_id_t addrid)758 damap_id_rele(damap_t *damapp, damap_id_t addrid)
759 {
760 	dam_t *mapp = (dam_t *)damapp;
761 	dam_da_t *passp;
762 	char *addr;
763 
764 	passp = ddi_get_soft_state(mapp->dam_da, (id_t)addrid);
765 	ASSERT(passp);
766 
767 	addr = damap_id2addr(damapp, addrid);
768 	DTRACE_PROBE4(damap__id__rele,
769 	    char *, mapp->dam_name, dam_t *, mapp,
770 	    char *, addr, int, passp->da_ref);
771 
772 	mutex_enter(&mapp->dam_lock);
773 
774 	/*
775 	 * teardown address if last outstanding reference
776 	 */
777 	if (--passp->da_ref == 0)
778 		dam_addr_release(mapp, (id_t)addrid);
779 
780 	mutex_exit(&mapp->dam_lock);
781 }
782 
783 /*
784  * Return current reference count on address reference in map
785  *
786  * damapp:	address map handle
787  * addrid:	address ID
788  *
789  * Returns:	DAM_SUCCESS
790  *		DAM_FAILURE
791  */
792 int
damap_id_ref(damap_t * damapp,damap_id_t addrid)793 damap_id_ref(damap_t *damapp, damap_id_t addrid)
794 {
795 	dam_t *mapp = (dam_t *)damapp;
796 	dam_da_t *passp;
797 	int ref = -1;
798 
799 	passp = ddi_get_soft_state(mapp->dam_da, (id_t)addrid);
800 	if (passp)
801 		ref = passp->da_ref;
802 
803 	return (ref);
804 }
805 
806 /*
807  * Return next address ID in list
808  *
809  * damapp:	address map handle
810  * damap_list:	address ID list passed to config|unconfig
811  *		returned by look by lookup_all
812  * last:	last ID returned, 0 is start of list
813  *
814  * Returns:	addrid		Next ID from the list
815  *		0		End of the list
816  */
817 damap_id_t
damap_id_next(damap_t * damapp,damap_id_list_t damap_list,damap_id_t last)818 damap_id_next(damap_t *damapp, damap_id_list_t damap_list, damap_id_t last)
819 {
820 	int i, start;
821 	dam_t *mapp = (dam_t *)damapp;
822 	bitset_t *dam_list = (bitset_t *)damap_list;
823 
824 	if (!mapp || !dam_list)
825 		return ((damap_id_t)0);
826 
827 	start = (int)last + 1;
828 	for (i = start; i < mapp->dam_high; i++) {
829 		if (bitset_in_set(dam_list, i)) {
830 			return ((damap_id_t)i);
831 		}
832 	}
833 	return ((damap_id_t)0);
834 }
835 
836 /*
837  * Set config private data
838  *
839  * damapp:	address map handle
840  * addrid:	address ID
841  * cfg_priv:	configuration private data
842  *
843  */
844 void
damap_id_priv_set(damap_t * damapp,damap_id_t addrid,void * cfg_priv)845 damap_id_priv_set(damap_t *damapp, damap_id_t addrid, void *cfg_priv)
846 {
847 	dam_t *mapp = (dam_t *)damapp;
848 	dam_da_t *passp;
849 
850 	mutex_enter(&mapp->dam_lock);
851 	passp = ddi_get_soft_state(mapp->dam_da, (id_t)addrid);
852 	if (!passp) {
853 		mutex_exit(&mapp->dam_lock);
854 		return;
855 	}
856 	passp->da_cfg_priv = cfg_priv;
857 	mutex_exit(&mapp->dam_lock);
858 }
859 
860 /*
861  * Get config private data
862  *
863  * damapp:	address map handle
864  * addrid:	address ID
865  *
866  * Returns:	configuration private data
867  */
868 void *
damap_id_priv_get(damap_t * damapp,damap_id_t addrid)869 damap_id_priv_get(damap_t *damapp, damap_id_t addrid)
870 {
871 	dam_t *mapp = (dam_t *)damapp;
872 	dam_da_t *passp;
873 	void *rv;
874 
875 	mutex_enter(&mapp->dam_lock);
876 	passp = ddi_get_soft_state(mapp->dam_da, (id_t)addrid);
877 	if (!passp) {
878 		mutex_exit(&mapp->dam_lock);
879 		return (NULL);
880 	}
881 	rv = passp->da_cfg_priv;
882 	mutex_exit(&mapp->dam_lock);
883 	return (rv);
884 }
885 
886 /*
887  * Lookup a single address in the active address map
888  *
889  * damapp:	address map handle
890  * address:	address string
891  *
892  * Returns:	ID of active/stable address
893  *		0	Address not in stable set
894  *
895  * Future: Allow the caller to wait for stabilize before returning not found.
896  */
897 damap_id_t
damap_lookup(damap_t * damapp,char * address)898 damap_lookup(damap_t *damapp, char *address)
899 {
900 	dam_t *mapp = (dam_t *)damapp;
901 	id_t addrid = 0;
902 	dam_da_t *passp = NULL;
903 
904 	DTRACE_PROBE3(damap__lookup,
905 	    char *, mapp->dam_name, dam_t *, mapp,
906 	    char *, address);
907 	mutex_enter(&mapp->dam_lock);
908 	if (!mapp->dam_high)
909 		addrid = 0;
910 	else
911 		addrid = ddi_strid_str2id(mapp->dam_addr_hash, address);
912 	if (addrid) {
913 		if (DAM_IS_STABLE(mapp, addrid)) {
914 			passp = ddi_get_soft_state(mapp->dam_da, addrid);
915 			ASSERT(passp);
916 			if (passp) {
917 				passp->da_ref++;
918 			} else {
919 				addrid = 0;
920 			}
921 		} else {
922 			addrid = 0;
923 		}
924 	}
925 	mutex_exit(&mapp->dam_lock);
926 	DTRACE_PROBE4(damap__lookup__return,
927 	    char *, mapp->dam_name, dam_t *, mapp,
928 	    char *, address, int, addrid);
929 	return ((damap_id_t)addrid);
930 }
931 
932 
933 /*
934  * Return the list of stable addresses in the map
935  *
936  * damapp:	address map handle
937  * id_listp:	pointer to list of address IDs in stable map (returned)
938  *
939  * Returns:	# of entries returned in alist
940  */
941 int
damap_lookup_all(damap_t * damapp,damap_id_list_t * id_listp)942 damap_lookup_all(damap_t *damapp, damap_id_list_t *id_listp)
943 {
944 	dam_t *mapp = (dam_t *)damapp;
945 	int mapsz = mapp->dam_size;
946 	int n_ids, i;
947 	bitset_t *bsp;
948 	char	 *addrp;
949 	dam_da_t *passp;
950 
951 	DTRACE_PROBE2(damap__lookup__all,
952 	    char *, mapp->dam_name, dam_t *, mapp);
953 	mutex_enter(&mapp->dam_lock);
954 	if (!mapp->dam_high) {
955 		*id_listp = (damap_id_list_t)NULL;
956 		mutex_exit(&mapp->dam_lock);
957 		DTRACE_PROBE2(damap__lookup__all__nomap,
958 		    char *, mapp->dam_name, dam_t *, mapp);
959 		return (0);
960 	}
961 	bsp = kmem_alloc(sizeof (*bsp), KM_SLEEP);
962 	bitset_init(bsp);
963 	bitset_resize(bsp, mapsz);
964 	bitset_copy(&mapp->dam_active_set, bsp);
965 	for (n_ids = 0, i = 1; i < mapsz; i++) {
966 		if (bitset_in_set(bsp, i)) {
967 			passp = ddi_get_soft_state(mapp->dam_da, i);
968 			ASSERT(passp);
969 			if (passp) {
970 				addrp = damap_id2addr(damapp, i);
971 				DTRACE_PROBE3(damap__lookup__all__item,
972 				    char *, mapp->dam_name, dam_t *, mapp,
973 				    char *, addrp);
974 				passp->da_ref++;
975 				n_ids++;
976 			}
977 		}
978 	}
979 	if (n_ids) {
980 		*id_listp = (damap_id_list_t)bsp;
981 		mutex_exit(&mapp->dam_lock);
982 		return (n_ids);
983 	} else {
984 		*id_listp = (damap_id_list_t)NULL;
985 		bitset_fini(bsp);
986 		kmem_free(bsp, sizeof (*bsp));
987 		mutex_exit(&mapp->dam_lock);
988 		return (0);
989 	}
990 }
991 
992 /*
993  * Release the address list returned by damap_lookup_all()
994  *
995  * mapp:	address map handle
996  * id_list:	list of address IDs returned in damap_lookup_all()
997  */
998 void
damap_id_list_rele(damap_t * damapp,damap_id_list_t id_list)999 damap_id_list_rele(damap_t *damapp, damap_id_list_t id_list)
1000 {
1001 	dam_t *mapp = (dam_t *)damapp;
1002 	int i;
1003 
1004 	if (id_list == NULL)
1005 		return;
1006 
1007 	mutex_enter(&mapp->dam_lock);
1008 	for (i = 1; i < mapp->dam_high; i++) {
1009 		if (bitset_in_set((bitset_t *)id_list, i))
1010 			(void) dam_addr_release(mapp, i);
1011 	}
1012 	mutex_exit(&mapp->dam_lock);
1013 	bitset_fini((bitset_t *)id_list);
1014 	kmem_free((void *)id_list, sizeof (bitset_t));
1015 }
1016 
1017 /*
1018  * activate an address that has passed the stabilization interval
1019  */
1020 static void
dam_addr_activate(dam_t * mapp,id_t addrid)1021 dam_addr_activate(dam_t *mapp, id_t addrid)
1022 {
1023 	dam_da_t *passp;
1024 	int config_rv;
1025 	char *addrstr;
1026 
1027 	mutex_enter(&mapp->dam_lock);
1028 	bitset_add(&mapp->dam_active_set, addrid);
1029 	passp = ddi_get_soft_state(mapp->dam_da, addrid);
1030 	ASSERT(passp);
1031 
1032 	/*
1033 	 * copy the reported nvlist and provider private data
1034 	 */
1035 	addrstr = ddi_strid_id2str(mapp->dam_addr_hash, addrid);
1036 	DTRACE_PROBE3(damap__addr__activate__start,
1037 	    char *, mapp->dam_name, dam_t *, mapp,
1038 	    char *, addrstr);
1039 	passp->da_nvl = passp->da_nvl_rpt;
1040 	passp->da_ppriv = passp->da_ppriv_rpt;
1041 	passp->da_ppriv_rpt = NULL;
1042 	passp->da_nvl_rpt = NULL;
1043 	passp->da_last_stable = gethrtime();
1044 	passp->da_stable_cnt++;
1045 	mutex_exit(&mapp->dam_lock);
1046 	if (mapp->dam_activate_cb) {
1047 		(*mapp->dam_activate_cb)(mapp->dam_activate_arg, addrstr,
1048 		    addrid, &passp->da_ppriv_rpt);
1049 	}
1050 
1051 	/*
1052 	 * call the address-specific configuration action as part of
1053 	 * activation.
1054 	 */
1055 	config_rv = (*mapp->dam_configure_cb)(mapp->dam_config_arg, mapp,
1056 	    addrid);
1057 	if (config_rv != DAM_SUCCESS) {
1058 		mutex_enter(&mapp->dam_lock);
1059 		passp->da_flags |= DA_FAILED_CONFIG;
1060 		mutex_exit(&mapp->dam_lock);
1061 		DTRACE_PROBE3(damap__addr__activate__config__failure,
1062 		    char *, mapp->dam_name, dam_t *, mapp,
1063 		    char *, addrstr);
1064 		dam_deact_cleanup(mapp, addrid, addrstr,
1065 		    DAMAP_DEACT_RSN_CFG_FAIL);
1066 	} else {
1067 		DTRACE_PROBE3(damap__addr__activate__end,
1068 		    char *, mapp->dam_name, dam_t *, mapp,
1069 		    char *, addrstr);
1070 	}
1071 }
1072 
1073 /*
1074  * deactivate a previously stable address
1075  */
1076 static void
dam_addr_deactivate(dam_t * mapp,id_t addrid)1077 dam_addr_deactivate(dam_t *mapp, id_t addrid)
1078 {
1079 	char *addrstr;
1080 
1081 	addrstr = ddi_strid_id2str(mapp->dam_addr_hash, addrid);
1082 	DTRACE_PROBE3(damap__addr__deactivate__start,
1083 	    char *, mapp->dam_name, dam_t *, mapp,
1084 	    char *, addrstr);
1085 
1086 	/*
1087 	 * call the unconfiguration callback
1088 	 */
1089 	(*mapp->dam_unconfig_cb)(mapp->dam_config_arg, mapp, addrid);
1090 	dam_deact_cleanup(mapp, addrid, addrstr, DAMAP_DEACT_RSN_GONE);
1091 }
1092 
1093 static void
dam_deact_cleanup(dam_t * mapp,id_t addrid,char * addrstr,damap_deact_rsn_t deact_rsn)1094 dam_deact_cleanup(dam_t *mapp, id_t addrid, char *addrstr,
1095     damap_deact_rsn_t deact_rsn)
1096 {
1097 	dam_da_t *passp;
1098 
1099 	passp = ddi_get_soft_state(mapp->dam_da, addrid);
1100 	ASSERT(passp);
1101 	if (mapp->dam_deactivate_cb)
1102 		(*mapp->dam_deactivate_cb)(mapp->dam_activate_arg,
1103 		    ddi_strid_id2str(mapp->dam_addr_hash, addrid),
1104 		    addrid, passp->da_ppriv, deact_rsn);
1105 
1106 	/*
1107 	 * clear the active bit and free the backing info for
1108 	 * this address
1109 	 */
1110 	mutex_enter(&mapp->dam_lock);
1111 	bitset_del(&mapp->dam_active_set, addrid);
1112 	passp->da_ppriv = NULL;
1113 	if (passp->da_nvl)
1114 		nvlist_free(passp->da_nvl);
1115 	passp->da_nvl = NULL;
1116 	passp->da_ppriv_rpt = NULL;
1117 	if (passp->da_nvl_rpt)
1118 		nvlist_free(passp->da_nvl_rpt);
1119 	passp->da_nvl_rpt = NULL;
1120 
1121 	DTRACE_PROBE3(damap__addr__deactivate__end,
1122 	    char *, mapp->dam_name, dam_t *, mapp,
1123 	    char *, addrstr);
1124 
1125 	(void) dam_addr_release(mapp, addrid);
1126 	mutex_exit(&mapp->dam_lock);
1127 }
1128 
1129 /*
1130  * taskq callback for multi-thread activation
1131  */
1132 static void
dam_tq_config(void * arg)1133 dam_tq_config(void *arg)
1134 {
1135 	cfg_tqd_t *tqd = (cfg_tqd_t *)arg;
1136 
1137 	dam_addr_activate(tqd->tqd_mapp, tqd->tqd_id);
1138 	kmem_free(tqd, sizeof (*tqd));
1139 }
1140 
1141 /*
1142  * taskq callback for multi-thread deactivation
1143  */
1144 static void
dam_tq_unconfig(void * arg)1145 dam_tq_unconfig(void *arg)
1146 {
1147 	cfg_tqd_t *tqd = (cfg_tqd_t *)arg;
1148 
1149 	dam_addr_deactivate(tqd->tqd_mapp, tqd->tqd_id);
1150 	kmem_free(tqd, sizeof (*tqd));
1151 }
1152 
1153 /*
1154  * Activate a set of stabilized addresses
1155  */
1156 static void
dam_addrset_activate(dam_t * mapp,bitset_t * activate)1157 dam_addrset_activate(dam_t *mapp, bitset_t *activate)
1158 {
1159 
1160 	int i, nset;
1161 	taskq_t *tqp = NULL;
1162 	cfg_tqd_t *tqd = NULL;
1163 	char tqn[TASKQ_NAMELEN];
1164 	extern pri_t maxclsyspri;
1165 
1166 	if (mapp->dam_options & DAMAP_MTCONFIG) {
1167 		/*
1168 		 * calculate the # of taskq threads to create
1169 		 */
1170 		for (i = 1, nset = 0; i < mapp->dam_high; i++)
1171 			if (bitset_in_set(activate, i))
1172 				nset++;
1173 		ASSERT(nset);
1174 		(void) snprintf(tqn, sizeof (tqn), "actv-%s", mapp->dam_name);
1175 		tqp = taskq_create(tqn, nset, maxclsyspri, 1,
1176 		    INT_MAX, TASKQ_PREPOPULATE);
1177 	}
1178 	for (i = 1; i < mapp->dam_high; i++) {
1179 		if (bitset_in_set(activate, i)) {
1180 			if (!tqp)
1181 				dam_addr_activate(mapp, i);
1182 			else {
1183 				/*
1184 				 * multi-threaded activation
1185 				 */
1186 				tqd = kmem_alloc(sizeof (*tqd), KM_SLEEP);
1187 				tqd->tqd_mapp = mapp;
1188 				tqd->tqd_id = i;
1189 				(void) taskq_dispatch(tqp, dam_tq_config,
1190 				    tqd, TQ_SLEEP);
1191 			}
1192 		}
1193 	}
1194 	if (tqp) {
1195 		taskq_wait(tqp);
1196 		taskq_destroy(tqp);
1197 	}
1198 }
1199 
1200 /*
1201  * Deactivate a set of stabilized addresses
1202  */
1203 static void
dam_addrset_deactivate(dam_t * mapp,bitset_t * deactivate)1204 dam_addrset_deactivate(dam_t *mapp, bitset_t *deactivate)
1205 {
1206 	int i, nset;
1207 	taskq_t *tqp = NULL;
1208 	cfg_tqd_t *tqd = NULL;
1209 	char tqn[TASKQ_NAMELEN];
1210 
1211 	DTRACE_PROBE2(damap__addrset__deactivate,
1212 	    char *, mapp->dam_name, dam_t *, mapp);
1213 
1214 	if (mapp->dam_options & DAMAP_MTCONFIG) {
1215 		/*
1216 		 * compute the # of taskq threads to dispatch
1217 		 */
1218 		for (i = 1, nset = 0; i < mapp->dam_high; i++)
1219 			if (bitset_in_set(deactivate, i))
1220 				nset++;
1221 		(void) snprintf(tqn, sizeof (tqn), "deactv-%s",
1222 		    mapp->dam_name);
1223 		tqp = taskq_create(tqn, nset, maxclsyspri, 1,
1224 		    INT_MAX, TASKQ_PREPOPULATE);
1225 	}
1226 	for (i = 1; i < mapp->dam_high; i++) {
1227 		if (bitset_in_set(deactivate, i)) {
1228 			if (!tqp) {
1229 				dam_addr_deactivate(mapp, i);
1230 			} else {
1231 				tqd = kmem_alloc(sizeof (*tqd), KM_SLEEP);
1232 				tqd->tqd_mapp = mapp;
1233 				tqd->tqd_id = i;
1234 				(void) taskq_dispatch(tqp,
1235 				    dam_tq_unconfig, tqd, TQ_SLEEP);
1236 			}
1237 		}
1238 	}
1239 
1240 	if (tqp) {
1241 		taskq_wait(tqp);
1242 		taskq_destroy(tqp);
1243 	}
1244 }
1245 
1246 /*
1247  * Release a previously activated address
1248  */
1249 static void
dam_addr_release(dam_t * mapp,id_t addrid)1250 dam_addr_release(dam_t *mapp, id_t addrid)
1251 {
1252 	dam_da_t *passp;
1253 	char	 *addrstr;
1254 
1255 
1256 	ASSERT(mutex_owned(&mapp->dam_lock));
1257 	passp = ddi_get_soft_state(mapp->dam_da, addrid);
1258 	ASSERT(passp);
1259 
1260 	addrstr = ddi_strid_id2str(mapp->dam_addr_hash, addrid);
1261 	DTRACE_PROBE3(damap__addr__release,
1262 	    char *, mapp->dam_name, dam_t *, mapp,
1263 	    char *, addrstr);
1264 
1265 	/*
1266 	 * defer releasing the address until outstanding references
1267 	 * are released
1268 	 */
1269 	if (passp->da_ref > 1) {
1270 		DTRACE_PROBE4(damap__addr__release__outstanding__refs,
1271 		    char *, mapp->dam_name, dam_t *, mapp,
1272 		    char *, addrstr, int, passp->da_ref);
1273 		return;
1274 	}
1275 
1276 	/*
1277 	 * allow pending reports to stabilize
1278 	 */
1279 	if (DAM_IN_REPORT(mapp, addrid)) {
1280 		DTRACE_PROBE3(damap__addr__release__report__pending,
1281 		    char *, mapp->dam_name, dam_t *, mapp,
1282 		    char *, addrstr);
1283 		return;
1284 	}
1285 
1286 	ddi_strid_free(mapp->dam_addr_hash, addrid);
1287 	ddi_soft_state_free(mapp->dam_da, addrid);
1288 }
1289 
1290 /*
1291  * process stabilized address reports
1292  */
1293 static void
dam_stabilize_map(void * arg)1294 dam_stabilize_map(void *arg)
1295 {
1296 	dam_t *mapp = (dam_t *)arg;
1297 	bitset_t delta;
1298 	bitset_t cfg;
1299 	bitset_t uncfg;
1300 	int has_cfg, has_uncfg;
1301 	uint32_t i, n_active;
1302 
1303 	DTRACE_PROBE2(damap__stabilize__map,
1304 	    char *, mapp->dam_name, dam_t *, mapp);
1305 
1306 	bitset_init(&delta);
1307 	bitset_resize(&delta, mapp->dam_size);
1308 	bitset_init(&cfg);
1309 	bitset_resize(&cfg, mapp->dam_size);
1310 	bitset_init(&uncfg);
1311 	bitset_resize(&uncfg, mapp->dam_size);
1312 
1313 	/*
1314 	 * determine which addresses have changed during
1315 	 * this stabilization cycle
1316 	 */
1317 	mutex_enter(&mapp->dam_lock);
1318 	ASSERT(mapp->dam_flags & DAM_SPEND);
1319 	if (!bitset_xor(&mapp->dam_active_set, &mapp->dam_stable_set,
1320 	    &delta)) {
1321 		/*
1322 		 * no difference
1323 		 */
1324 		bitset_zero(&mapp->dam_stable_set);
1325 		mapp->dam_flags &= ~DAM_SPEND;
1326 		cv_signal(&mapp->dam_sync_cv);
1327 		mutex_exit(&mapp->dam_lock);
1328 
1329 		bitset_fini(&uncfg);
1330 		bitset_fini(&cfg);
1331 		bitset_fini(&delta);
1332 		DTRACE_PROBE2(damap__stabilize__map__nochange,
1333 		    char *, mapp->dam_name, dam_t *, mapp);
1334 		return;
1335 	}
1336 
1337 	/*
1338 	 * compute the sets of addresses to be activated and deactivated
1339 	 */
1340 	has_cfg = bitset_and(&delta, &mapp->dam_stable_set, &cfg);
1341 	has_uncfg = bitset_and(&delta, &mapp->dam_active_set, &uncfg);
1342 
1343 	/*
1344 	 * drop map lock while invoking callouts
1345 	 */
1346 	mutex_exit(&mapp->dam_lock);
1347 
1348 	/*
1349 	 * activate all newly stable addresss
1350 	 */
1351 	if (has_cfg)
1352 		dam_addrset_activate(mapp, &cfg);
1353 
1354 	/*
1355 	 * deactivate addresss which are no longer in the map
1356 	 */
1357 	if (has_uncfg)
1358 		dam_addrset_deactivate(mapp, &uncfg);
1359 
1360 
1361 	/*
1362 	 * timestamp the last stable time and increment the kstat keeping
1363 	 * the # of of stable cycles for the map
1364 	 */
1365 	mutex_enter(&mapp->dam_lock);
1366 	bitset_zero(&mapp->dam_stable_set);
1367 	mapp->dam_last_stable = gethrtime();
1368 	mapp->dam_stable_cnt++;
1369 	DAM_INCR_STAT(mapp, dam_cycles);
1370 
1371 	/*
1372 	 * determine the number of stable addresses
1373 	 * and update the n_active kstat for this map
1374 	 */
1375 	for (i = 1, n_active = 0; i < mapp->dam_high; i++)
1376 		if (bitset_in_set(&mapp->dam_active_set, i))
1377 			n_active++;
1378 	DAM_SET_STAT(mapp, dam_active, n_active);
1379 
1380 	DTRACE_PROBE3(damap__map__stable__end,
1381 	    char *, mapp->dam_name, dam_t *, mapp,
1382 	    int, n_active);
1383 
1384 	mapp->dam_flags &= ~DAM_SPEND;
1385 	cv_signal(&mapp->dam_sync_cv);
1386 	mutex_exit(&mapp->dam_lock);
1387 
1388 	bitset_fini(&uncfg);
1389 	bitset_fini(&cfg);
1390 	bitset_fini(&delta);
1391 }
1392 
1393 /*
1394  * per-address stabilization timeout
1395  */
1396 static void
dam_addr_stable_cb(void * arg)1397 dam_addr_stable_cb(void *arg)
1398 {
1399 	dam_t *mapp = (dam_t *)arg;
1400 	int i;
1401 	dam_da_t *passp;
1402 	int spend = 0;
1403 	int tpend = 0;
1404 	int64_t ts, next_ticks, delta_ticks;
1405 
1406 	mutex_enter(&mapp->dam_lock);
1407 	if (mapp->dam_tid == 0) {
1408 		DTRACE_PROBE2(damap__map__addr__stable__cancelled,
1409 		    char *, mapp->dam_name, dam_t *, mapp);
1410 		mutex_exit(&mapp->dam_lock);
1411 		return;
1412 	}
1413 	mapp->dam_tid = 0;
1414 
1415 	/*
1416 	 * If still under stabilization, reschedule timeout,
1417 	 * otherwise dispatch the task to activate and deactivate the
1418 	 * new stable address
1419 	 */
1420 	if (mapp->dam_flags & DAM_SPEND) {
1421 		DAM_INCR_STAT(mapp, dam_overrun);
1422 		mapp->dam_stable_overrun++;
1423 		DTRACE_PROBE2(damap__map__addr__stable__overrun,
1424 		    char *, mapp->dam_name, dam_t *, mapp);
1425 		dam_sched_timeout(dam_addr_stable_cb, mapp,
1426 		    mapp->dam_stable_ticks);
1427 		mutex_exit(&mapp->dam_lock);
1428 		return;
1429 	}
1430 
1431 	DAM_SET_STAT(mapp, dam_overrun, 0);
1432 	mapp->dam_stable_overrun = 0;
1433 
1434 	/* See if any reports stabalized and compute next timeout. */
1435 	ts = ddi_get_lbolt64();
1436 	next_ticks = mapp->dam_stable_ticks;
1437 	for (i = 1; i < mapp->dam_high; i++) {
1438 		if (bitset_in_set(&mapp->dam_report_set, i)) {
1439 			passp = ddi_get_soft_state(mapp->dam_da, i);
1440 			ASSERT(passp);
1441 
1442 			if (passp->da_deadline <= ts)
1443 				spend++;	/* report has stabilized */
1444 			else {
1445 				/* not stabilized, determine next map timeout */
1446 				tpend++;
1447 				delta_ticks = passp->da_deadline - ts;
1448 				if (delta_ticks < next_ticks)
1449 					next_ticks = delta_ticks;
1450 			}
1451 		}
1452 	}
1453 
1454 	/*
1455 	 * schedule system_taskq activation of stabilized reports
1456 	 */
1457 	if (spend) {
1458 		if (taskq_dispatch(system_taskq, dam_stabilize_map,
1459 		    mapp, TQ_NOSLEEP | TQ_NOQUEUE)) {
1460 			DTRACE_PROBE2(damap__map__addr__stable__start,
1461 			    char *, mapp->dam_name, dam_t *, mapp);
1462 
1463 			/*
1464 			 * The stable_set we compute below stays pending until
1465 			 * processed by dam_stabilize_map. We can't set
1466 			 * DAM_SPEND (or bitset_del things from the
1467 			 * report_set) until we *know* that we can handoff the
1468 			 * result to dam_stabilize_map. If dam_stabilize_map
1469 			 * starts executing before we are complete, it will
1470 			 * block on the dam_lock mutex until we are ready.
1471 			 */
1472 			mapp->dam_flags |= DAM_SPEND;
1473 
1474 			/*
1475 			 * Copy the current active_set to the stable_set, then
1476 			 * add or remove stabilized report_set address from
1477 			 * the stable set (and delete them from the report_set).
1478 			 */
1479 			bitset_copy(&mapp->dam_active_set,
1480 			    &mapp->dam_stable_set);
1481 			for (i = 1; i < mapp->dam_high; i++) {
1482 				if (!bitset_in_set(&mapp->dam_report_set, i))
1483 					continue;
1484 
1485 				passp = ddi_get_soft_state(mapp->dam_da, i);
1486 				if (passp->da_deadline > ts)
1487 					continue; /* report not stabilized */
1488 
1489 				/* report has stabilized */
1490 				if (passp->da_flags & DA_RELE)
1491 					bitset_del(&mapp->dam_stable_set, i);
1492 				else
1493 					bitset_add(&mapp->dam_stable_set, i);
1494 
1495 				bitset_del(&mapp->dam_report_set, i);
1496 			}
1497 		} else {
1498 			DTRACE_PROBE2(damap__map__addr__stable__spendfail,
1499 			    char *, mapp->dam_name, dam_t *, mapp);
1500 
1501 			/*
1502 			 * Avoid waiting the entire stabalization
1503 			 * time again if taskq_diskpatch fails.
1504 			 */
1505 			tpend++;
1506 			delta_ticks = drv_usectohz(
1507 			    damap_taskq_dispatch_retry_usec);
1508 			if (delta_ticks < next_ticks)
1509 				next_ticks = delta_ticks;
1510 		}
1511 	}
1512 
1513 	/*
1514 	 * reschedule the stabilization timer if there are reports
1515 	 * still pending
1516 	 */
1517 	if (tpend) {
1518 		DTRACE_PROBE2(damap__map__addr__stable__tpend, char *,
1519 		    mapp->dam_name, dam_t *, mapp);
1520 		dam_sched_timeout(dam_addr_stable_cb, mapp,
1521 		    (clock_t)next_ticks);
1522 	}
1523 
1524 	mutex_exit(&mapp->dam_lock);
1525 }
1526 
1527 /*
1528  * fullset stabilization timeout callback
1529  */
1530 static void
dam_addrset_stable_cb(void * arg)1531 dam_addrset_stable_cb(void *arg)
1532 {
1533 	dam_t *mapp = (dam_t *)arg;
1534 
1535 	mutex_enter(&mapp->dam_lock);
1536 	if (mapp->dam_tid == 0) {
1537 		mutex_exit(&mapp->dam_lock);
1538 		DTRACE_PROBE2(damap__map__addrset__stable__cancelled,
1539 		    char *, mapp->dam_name, dam_t *, mapp);
1540 		return;
1541 	}
1542 	mapp->dam_tid = 0;
1543 
1544 	/*
1545 	 * If map still underoing stabilization reschedule timeout,
1546 	 * else dispatch the task to configure the new stable set of
1547 	 * addresses.
1548 	 */
1549 	if ((mapp->dam_flags & DAM_SPEND) ||
1550 	    (taskq_dispatch(system_taskq, dam_stabilize_map, mapp,
1551 	    TQ_NOSLEEP | TQ_NOQUEUE) == NULL)) {
1552 		DAM_INCR_STAT(mapp, dam_overrun);
1553 		mapp->dam_stable_overrun++;
1554 		dam_sched_timeout(dam_addrset_stable_cb, mapp,
1555 		    drv_usectohz(damap_taskq_dispatch_retry_usec));
1556 
1557 		DTRACE_PROBE2(damap__map__addrset__stable__overrun,
1558 		    char *, mapp->dam_name, dam_t *, mapp);
1559 		mutex_exit(&mapp->dam_lock);
1560 		return;
1561 	}
1562 
1563 	DAM_SET_STAT(mapp, dam_overrun, 0);
1564 	mapp->dam_stable_overrun = 0;
1565 	bitset_copy(&mapp->dam_report_set, &mapp->dam_stable_set);
1566 	bitset_zero(&mapp->dam_report_set);
1567 	mapp->dam_flags |= DAM_SPEND;
1568 	mapp->dam_flags &= ~DAM_SETADD;
1569 	/* NOTE: don't need cv_signal since DAM_SPEND is still set */
1570 
1571 	DTRACE_PROBE2(damap__map__addrset__stable__start,
1572 	    char *, mapp->dam_name, dam_t *, mapp);
1573 	mutex_exit(&mapp->dam_lock);
1574 }
1575 
1576 /*
1577  * schedule map timeout in 'ticks' ticks
1578  * if map timer is currently running, cancel if ticks == 0
1579  */
1580 static void
dam_sched_timeout(void (* timeout_cb)(),dam_t * mapp,clock_t ticks)1581 dam_sched_timeout(void (*timeout_cb)(), dam_t *mapp, clock_t ticks)
1582 {
1583 	timeout_id_t tid;
1584 
1585 	DTRACE_PROBE4(damap__sched__timeout,
1586 	    char *, mapp->dam_name, dam_t *, mapp,
1587 	    int, ticks, timeout_id_t, mapp->dam_tid);
1588 
1589 	ASSERT(mutex_owned(&mapp->dam_lock));
1590 	if ((tid = mapp->dam_tid) != 0) {
1591 		if (ticks == 0) {
1592 			mapp->dam_tid = 0;
1593 			mutex_exit(&mapp->dam_lock);
1594 			(void) untimeout(tid);
1595 			mutex_enter(&mapp->dam_lock);
1596 		}
1597 	} else {
1598 		if (timeout_cb && (ticks != 0))
1599 			mapp->dam_tid = timeout(timeout_cb, mapp, ticks);
1600 	}
1601 }
1602 
1603 /*
1604  * report addition or removal of an address
1605  */
1606 static void
dam_addr_report(dam_t * mapp,dam_da_t * passp,id_t addrid,int rpt_type)1607 dam_addr_report(dam_t *mapp, dam_da_t *passp, id_t addrid, int rpt_type)
1608 {
1609 	char *addrstr = damap_id2addr((damap_t *)mapp, addrid);
1610 
1611 	DTRACE_PROBE4(damap__addr__report,
1612 	    char *, mapp->dam_name, dam_t *, mapp,
1613 	    char *, addrstr, int, rpt_type);
1614 
1615 	ASSERT(mutex_owned(&mapp->dam_lock));
1616 	ASSERT(!DAM_IN_REPORT(mapp, addrid));
1617 	passp->da_last_report = gethrtime();
1618 	mapp->dam_last_update = gethrtime();
1619 	passp->da_report_cnt++;
1620 	passp->da_deadline = ddi_get_lbolt64() + mapp->dam_stable_ticks;
1621 	if (rpt_type == RPT_ADDR_DEL)
1622 		passp->da_flags |= DA_RELE;
1623 	else if (rpt_type == RPT_ADDR_ADD)
1624 		passp->da_flags &= ~DA_RELE;
1625 	bitset_add(&mapp->dam_report_set, addrid);
1626 	dam_sched_timeout(dam_addr_stable_cb, mapp, mapp->dam_stable_ticks);
1627 }
1628 
1629 /*
1630  * release an address report
1631  */
1632 static void
dam_addr_report_release(dam_t * mapp,id_t addrid)1633 dam_addr_report_release(dam_t *mapp, id_t addrid)
1634 {
1635 	dam_da_t *passp;
1636 	char *addrstr = damap_id2addr((damap_t *)mapp, addrid);
1637 
1638 	DTRACE_PROBE3(damap__addr__report__release,
1639 	    char *, mapp->dam_name, dam_t *, mapp,
1640 	    char *, addrstr);
1641 
1642 	ASSERT(mutex_owned(&mapp->dam_lock));
1643 	passp = ddi_get_soft_state(mapp->dam_da, addrid);
1644 	ASSERT(passp);
1645 	/*
1646 	 * clear the report bit
1647 	 * if the address has a registered deactivation handler and
1648 	 * we are holding a private data pointer and the address has not
1649 	 * stabilized, deactivate the address (private data).
1650 	 */
1651 	bitset_del(&mapp->dam_report_set, addrid);
1652 	if (!DAM_IS_STABLE(mapp, addrid) && mapp->dam_deactivate_cb &&
1653 	    passp->da_ppriv_rpt) {
1654 		mutex_exit(&mapp->dam_lock);
1655 		(*mapp->dam_deactivate_cb)(mapp->dam_activate_arg,
1656 		    ddi_strid_id2str(mapp->dam_addr_hash, addrid),
1657 		    addrid, passp->da_ppriv_rpt, DAMAP_DEACT_RSN_UNSTBL);
1658 		mutex_enter(&mapp->dam_lock);
1659 	}
1660 	passp->da_ppriv_rpt = NULL;
1661 	if (passp->da_nvl_rpt)
1662 		nvlist_free(passp->da_nvl_rpt);
1663 }
1664 
1665 /*
1666  * return the map ID of an address
1667  */
1668 static id_t
dam_get_addrid(dam_t * mapp,char * address)1669 dam_get_addrid(dam_t *mapp, char *address)
1670 {
1671 	damap_id_t addrid;
1672 	dam_da_t *passp;
1673 
1674 	ASSERT(mutex_owned(&mapp->dam_lock));
1675 	if ((addrid = ddi_strid_str2id(mapp->dam_addr_hash, address)) == 0) {
1676 		if ((addrid = ddi_strid_alloc(mapp->dam_addr_hash,
1677 		    address)) == (damap_id_t)0) {
1678 			return (0);
1679 		}
1680 		if (ddi_soft_state_zalloc(mapp->dam_da, addrid) !=
1681 		    DDI_SUCCESS) {
1682 			ddi_strid_free(mapp->dam_addr_hash, addrid);
1683 			return (0);
1684 		}
1685 
1686 		if (addrid >= mapp->dam_high)
1687 			mapp->dam_high = addrid + 1;
1688 
1689 		/*
1690 		 * expand bitmaps if ID has outgrown old map size
1691 		 */
1692 		if (mapp->dam_high > mapp->dam_size) {
1693 			mapp->dam_size = mapp->dam_size + DAM_SIZE_BUMP;
1694 			bitset_resize(&mapp->dam_active_set, mapp->dam_size);
1695 			bitset_resize(&mapp->dam_stable_set, mapp->dam_size);
1696 			bitset_resize(&mapp->dam_report_set, mapp->dam_size);
1697 		}
1698 
1699 		passp = ddi_get_soft_state(mapp->dam_da, addrid);
1700 		passp->da_ref = 1;
1701 		passp->da_addr = ddi_strid_id2str(mapp->dam_addr_hash,
1702 		    addrid); /* for mdb */
1703 	}
1704 	return (addrid);
1705 }
1706 
1707 /*
1708  * create and install map statistics
1709  */
1710 static int
dam_kstat_create(dam_t * mapp)1711 dam_kstat_create(dam_t *mapp)
1712 {
1713 	kstat_t			*mapsp;
1714 	struct dam_kstats	*statsp;
1715 
1716 	mapsp = kstat_create("dam", 0, mapp->dam_name, "damap",
1717 	    KSTAT_TYPE_NAMED,
1718 	    sizeof (struct dam_kstats) / sizeof (kstat_named_t), 0);
1719 
1720 	if (mapsp == NULL)
1721 		return (DDI_FAILURE);
1722 
1723 	statsp = (struct dam_kstats *)mapsp->ks_data;
1724 	kstat_named_init(&statsp->dam_cycles, "cycles", KSTAT_DATA_UINT32);
1725 	kstat_named_init(&statsp->dam_overrun, "overrun", KSTAT_DATA_UINT32);
1726 	kstat_named_init(&statsp->dam_jitter, "jitter", KSTAT_DATA_UINT32);
1727 	kstat_named_init(&statsp->dam_active, "active", KSTAT_DATA_UINT32);
1728 	kstat_install(mapsp);
1729 	mapp->dam_kstatsp = mapsp;
1730 	return (DDI_SUCCESS);
1731 }
1732