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 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #include <sys/sysmacros.h>
27 #include <sys/systm.h>
28 #include <sys/param.h>
29 #include <sys/debug.h>
30 #include <sys/kmem.h>
31 #include <sys/group.h>
32 #include <sys/cmn_err.h>
33
34
35 #define GRP_SET_SIZE_DEFAULT 2
36
37 static void group_grow_set(group_t *);
38 static void group_shrink_set(group_t *);
39 static void group_pack_set(void **, uint_t);
40
41 /*
42 * Initialize a group_t
43 */
44 void
45 group_create(group_t *g)
46 {
47 bzero(g, sizeof (group_t));
48 }
49
50 /*
51 * Destroy a group_t
52 * The group must already be empty
53 */
54 void
55 group_destroy(group_t *g)
56 {
57 ASSERT(g->grp_size == 0);
58
59 if (g->grp_capacity > 0) {
60 kmem_free(g->grp_set, g->grp_capacity * sizeof (void *));
61 g->grp_capacity = 0;
62 }
63 g->grp_set = NULL;
64 }
65
66 /*
67 * Empty a group_t
68 * Capacity is preserved.
69 */
70 void
71 group_empty(group_t *g)
72 {
73 int i;
74 int sz = g->grp_size;
75
76 g->grp_size = 0;
77 for (i = 0; i < sz; i++)
78 g->grp_set[i] = NULL;
79 }
80
81 /*
82 * Add element "e" to group "g"
83 *
84 * Returns -1 if addition would result in overcapacity, and
85 * resize operations aren't allowed, and 0 otherwise
86 */
87 int
88 group_add(group_t *g, void *e, int gflag)
89 {
90 int entry;
91
92 if ((gflag & GRP_NORESIZE) &&
93 g->grp_size == g->grp_capacity)
94 return (-1);
95
96 ASSERT(g->grp_size != g->grp_capacity || (gflag & GRP_RESIZE));
97
98 entry = g->grp_size++;
99 if (g->grp_size > g->grp_capacity)
100 group_grow_set(g);
101
102 ASSERT(g->grp_set[entry] == NULL);
103 g->grp_set[entry] = e;
104
105 return (0);
106 }
107
108 /*
109 * Remove element "e" from group "g"
110 *
111 * Returns -1 if "e" was not present in "g" and 0 otherwise
112 */
113 int
114 group_remove(group_t *g, void *e, int gflag)
115 {
116 int i;
117
118 if (g->grp_size == 0)
119 return (-1);
120
121 /*
122 * Find the element in the group's set
123 */
124 for (i = 0; i < g->grp_size; i++)
125 if (g->grp_set[i] == e)
126 break;
127 if (g->grp_set[i] != e)
128 return (-1);
129
130 g->grp_set[i] = NULL;
131 group_pack_set(g->grp_set, g->grp_size);
132 g->grp_size--;
133
134 if ((gflag & GRP_RESIZE) &&
135 g->grp_size > GRP_SET_SIZE_DEFAULT && ISP2(g->grp_size))
136 group_shrink_set(g);
137
138 return (0);
139 }
140
141 /*
142 * Expand the capacity of group "g" so that it may
143 * contain at least "n" elements
144 */
145 void
146 group_expand(group_t *g, uint_t n)
147 {
148 while (g->grp_capacity < n)
149 group_grow_set(g);
150 }
151
152 /*
153 * Upsize a group's holding capacity
154 */
155 static void
156 group_grow_set(group_t *g)
157 {
158 uint_t cap_old, cap_new;
159 void **set_old, **set_new;
160
161 cap_old = g->grp_capacity;
162 set_old = g->grp_set;
163
164 /*
165 * The array size grows in powers of two
166 */
167 if ((cap_new = (cap_old << 1)) == 0) {
168 /*
169 * The set is unallocated.
170 * Allocate a default sized set.
171 */
172 cap_new = GRP_SET_SIZE_DEFAULT;
173 g->grp_set = kmem_zalloc(cap_new * sizeof (void *), KM_SLEEP);
174 g->grp_capacity = cap_new;
175 } else {
176 /*
177 * Allocate a newly sized array,
178 * copy the data, and free the old array.
179 */
180 set_new = kmem_zalloc(cap_new * sizeof (void *), KM_SLEEP);
181 (void) kcopy(set_old, set_new, cap_old * sizeof (void *));
182 g->grp_set = set_new;
183 g->grp_capacity = cap_new;
184 kmem_free(set_old, cap_old * sizeof (void *));
185 }
186 /*
187 * The new array size should be a power of two
188 */
189 ASSERT(((cap_new - 1) & cap_new) == 0);
190 }
191
192 /*
193 * Downsize a group's holding capacity
194 */
195 static void
196 group_shrink_set(group_t *g)
197 {
198 uint_t cap_old, cap_new;
199 void **set_old, **set_new;
200
201 cap_old = g->grp_capacity;
202 set_old = g->grp_set;
203
204 /*
205 * The group's existing array size must already
206 * be a power of two
207 */
208 ASSERT(((cap_old - 1) & cap_old) == 0);
209 cap_new = cap_old >> 1;
210
211 /*
212 * GRP_SET_SIZE_DEFAULT is the minumum set size.
213 */
214 if (cap_new < GRP_SET_SIZE_DEFAULT)
215 return;
216
217 set_new = kmem_zalloc(cap_new * sizeof (void *), KM_SLEEP);
218 (void) kcopy(set_old, set_new, cap_new * sizeof (void *));
219 g->grp_capacity = cap_new;
220 g->grp_set = set_new;
221
222 ASSERT(((cap_new - 1) & cap_new) == 0);
223 kmem_free(set_old, cap_old * sizeof (void *));
224 }
225
226 /*
227 * Pack a group's set
228 * Element order is not preserved
229 */
230 static void
231 group_pack_set(void **set, uint_t sz)
232 {
233 uint_t i, j, free;
234
235 free = (uint_t)-1;
236
237 for (i = 0; i < sz; i++) {
238 if (set[i] == NULL && free == (uint_t)-1) {
239 /*
240 * Found a new free slot.
241 * Start packing from here.
242 */
243 free = i;
244 } else if (set[i] != NULL && free != (uint_t)-1) {
245 /*
246 * Found a slot to pack into
247 * an earlier free slot.
248 */
249 ASSERT(set[free] == NULL);
250 set[free] = set[i];
251 set[i] = NULL;
252
253 /*
254 * Find the next free slot
255 */
256 for (j = free + 1; set[j] != NULL; j++) {
257 ASSERT(j <= i);
258 if (j == i)
259 break;
260 }
261 if (set[j] == NULL)
262 free = j;
263 else
264 free = (uint_t)-1;
265 }
266 }
267 }
268
269 /*
270 * Initialize a group iterator cookie
271 */
272 void
273 group_iter_init(group_iter_t *iter)
274 {
275 *iter = 0;
276 }
277
278 /*
279 * Iterate over the elements in a group
280 */
281 void *
282 group_iterate(group_t *g, group_iter_t *iter)
283 {
284 uint_t idx = *iter;
285 void *data = NULL;
286
287 while (idx < g->grp_size) {
288 data = g->grp_set[idx++];
289 if (data != NULL)
290 break;
291 }
292 *iter = idx;
293
294 return (data);
295 }
296
297 /*
298 * Indexed access to a group's elements
299 */
300 void *
301 group_access_at(group_t *g, uint_t idx)
302 {
303 if (idx >= g->grp_capacity)
304 return (NULL);
305
306 return (g->grp_set[idx]);
307 }
308
309 /*
310 * Add a new ordered group element at specified
311 * index. The group must already be of sufficient
312 * capacity to hold an element at the specified index.
313 *
314 * Returns 0 if addition was sucessful, and -1 if the
315 * addition failed because the table was too small
316 */
317 int
318 group_add_at(group_t *g, void *e, uint_t idx)
319 {
320 if (idx >= g->grp_capacity)
321 return (-1);
322
323 if (idx >= g->grp_size)
324 g->grp_size = idx + 1;
325
326 ASSERT(g->grp_set[idx] == NULL);
327 g->grp_set[idx] = e;
328 return (0);
329 }
330
331 /*
332 * Remove the element at the specified index
333 */
334 void
335 group_remove_at(group_t *g, uint_t idx)
336 {
337 ASSERT(idx < g->grp_capacity);
338 g->grp_set[idx] = NULL;
339 }
340
341 /*
342 * Find an element in the group, and return its index
343 * Returns -1 if the element could not be found.
344 */
345 uint_t
346 group_find(group_t *g, void *e)
347 {
348 uint_t idx;
349
350 for (idx = 0; idx < g->grp_capacity; idx++) {
351 if (g->grp_set[idx] == e)
352 return (idx);
353 }
354 return ((uint_t)-1);
355 }
356
357 /*
358 * Return a string in a given buffer with list of integer entries in a group.
359 * The string concatenates consecutive integer ranges ax x-y.
360 * The resulting string looks like "1,2-5,8"
361 *
362 * The convert argument is used to map group elements to integer IDs.
363 */
364 char *
365 group2intlist(group_t *group, char *buffer, size_t len, int (convert)(void*))
366 {
367 char *ptr = buffer;
368 void *v;
369 group_iter_t iter;
370 boolean_t first_iteration = B_TRUE;
371 boolean_t first_value = B_TRUE;
372 int start = 0, end = 0;
373
374 /*
375 * Allow for the terminating NULL-byte
376 */
377 len = len -1;
378
379 group_iter_init(&iter);
380 while ((v = group_iterate(group, &iter)) != NULL && len > 0) {
381 int id = convert(v);
382 int nbytes = 0;
383
384 if (first_iteration) {
385 start = end = id;
386 first_iteration = B_FALSE;
387 } else if (end + 1 == id) {
388 /*
389 * Got consecutive ID, so extend end of range without
390 * doing anything since the range may extend further
391 */
392 end = id;
393 } else {
394 if (first_value) {
395 first_value = B_FALSE;
396 } else {
397 *ptr++ = ',';
398 len--;
399 }
400
401 if (len == 0)
402 break;
403
404 /*
405 * Next ID is not consecutive, so dump IDs gotten so
406 * far.
407 */
408 if (end > start + 1) /* range */
409 nbytes = snprintf(ptr, len, "%d-%d",
410 start, end);
411 else if (end > start) /* different values */
412 nbytes = snprintf(ptr, len, "%d,%d",
413 start, end);
414 else /* same value */
415 nbytes = snprintf(ptr, len, "%d", start);
416
417 if (nbytes <= 0) {
418 len = 0;
419 break;
420 }
421
422 /*
423 * Advance position in the string
424 */
425 ptr += nbytes;
426 len -= nbytes;
427
428 /*
429 * Try finding consecutive range starting from current
430 * ID.
431 */
432 start = end = id;
433 }
434 }
435
436 if (!first_value) {
437 *ptr++ = ',';
438 len--;
439 }
440 /*
441 * Print last ID(s)
442 */
443 if (len > 0) {
444 if (end > start + 1) {
445 (void) snprintf(ptr, len, "%d-%d", start, end);
446 } else if (end != start) {
447 (void) snprintf(ptr, len, "%d,%d", start, end);
448 } else {
449 (void) snprintf(ptr, len, "%d", start);
450 }
451 }
452
453 return (buffer);
454 }