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 2006 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #pragma ident "%Z%%M% %I% %E% SMI"
28
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <assert.h>
32 #include <sys/types.h>
33 #include <libdevinfo.h>
34 #include <fm/topo_mod.h>
35 #include <pcibus.h>
36 #include <did.h>
37
38 #include "did_impl.h"
39 #include "did_props.h"
40
41 static did_hash_t *did_hash_create(topo_mod_t *);
42 static void did_hash_destroy(did_hash_t *);
43
44 int
did_hash_init(topo_mod_t * hdl)45 did_hash_init(topo_mod_t *hdl)
46 {
47 did_hash_t *dh = did_hash_create(hdl);
48
49 if (dh != NULL) {
50 topo_mod_setspecific(hdl, (void *) dh);
51 return (0);
52 } else {
53 return (-1);
54 }
55 }
56
57 void
did_hash_fini(topo_mod_t * mod)58 did_hash_fini(topo_mod_t *mod)
59 {
60 did_hash_t *dh = (did_hash_t *)topo_mod_getspecific(mod);
61
62 topo_mod_setspecific(mod, NULL);
63 if (dh == NULL)
64 return;
65 did_hash_destroy(dh);
66 }
67
68 static uint64_t
did_dnhash(di_node_t key)69 did_dnhash(di_node_t key)
70 {
71 static uint64_t key_divisor = 0;
72 uint64_t keyn;
73
74 /*
75 * A bit naughty here, we're aware that a di_info_t is a
76 * pointer to a struct. For our hashing, we want use the size
77 * of that struct, which we determine here, somewhat
78 * impolitely.
79 */
80 if (key_divisor == 0)
81 key_divisor = sizeof (*key);
82
83 keyn = (uintptr_t)key;
84
85 return (keyn / key_divisor);
86 }
87
88 static did_hash_t *
did_hash_create(topo_mod_t * hdl)89 did_hash_create(topo_mod_t *hdl)
90 {
91 did_hash_t *r = topo_mod_zalloc(hdl, sizeof (did_hash_t));
92
93 if (r == NULL) {
94 (void) topo_mod_seterrno(hdl, EMOD_NOMEM);
95 return (NULL);
96 }
97 r->dph_mod = hdl;
98 r->dph_hashlen = REC_HASHLEN;
99 r->dph_hash = topo_mod_zalloc(hdl,
100 r->dph_hashlen * sizeof (did_t *));
101 if (r->dph_hash == NULL) {
102 topo_mod_free(hdl, r, sizeof (did_hash_t));
103 (void) topo_mod_seterrno(hdl, EMOD_NOMEM);
104 return (NULL);
105 }
106 return (r);
107 }
108
109 static void
did_hash_destroy(did_hash_t * ht)110 did_hash_destroy(did_hash_t *ht)
111 {
112 did_t *e, *n;
113 int idx;
114
115 if (ht == NULL)
116 return;
117 for (idx = 0; idx < ht->dph_hashlen; idx++) {
118 for (e = ht->dph_hash[idx]; e != NULL; ) {
119 n = e->dp_next;
120 did_destroy(e);
121 e = n;
122 }
123 }
124 topo_mod_free(ht->dph_mod,
125 ht->dph_hash, ht->dph_hashlen * sizeof (did_t *));
126 topo_mod_free(ht->dph_mod, ht, sizeof (did_hash_t));
127 }
128
129 void
did_hash_insert(topo_mod_t * mp,di_node_t key,did_t * new)130 did_hash_insert(topo_mod_t *mp, di_node_t key, did_t *new)
131 {
132 did_hash_t *tab = (did_hash_t *)topo_mod_getspecific(mp);
133 did_t *assertchk;
134 int idx = did_dnhash(key) % tab->dph_hashlen;
135
136 tab->dph_nelems++;
137 did_hold(new);
138 topo_mod_dprintf(tab->dph_mod, "Insert [key=%p] into %p, bucket %d\n",
139 key, (void *)tab, idx);
140 if (tab->dph_hash[idx] == NULL) {
141 tab->dph_hash[idx] = new;
142 topo_mod_dprintf(tab->dph_mod, "first entry.\n");
143 } else {
144 /*
145 * We should not be putting in a duplicate entry
146 */
147 for (assertchk = tab->dph_hash[idx];
148 assertchk != NULL;
149 assertchk = assertchk->dp_next)
150 assert(assertchk->dp_src != key);
151 new->dp_next = tab->dph_hash[idx];
152 tab->dph_hash[idx] = new;
153 }
154 }
155
156 did_t *
did_hash_lookup(topo_mod_t * mp,di_node_t key)157 did_hash_lookup(topo_mod_t *mp, di_node_t key)
158 {
159 did_t *e;
160 did_hash_t *tab = (did_hash_t *)topo_mod_getspecific(mp);
161 int idx = did_dnhash(key) % tab->dph_hashlen;
162
163 e = tab->dph_hash[idx];
164 while (e != NULL) {
165 if (e->dp_src == key) {
166 did_hold(e);
167 return (e);
168 }
169 e = e->dp_next;
170 }
171 return (NULL);
172 }
173