dapl_ring_buffer_util.c revision 9517:b4839b0aa7a4 
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) 2002-2003, Network Appliance, Inc. All rights reserved.
24 */
25
26/*
27 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
28 * Use is subject to license terms.
29 */
30
31/*
32 *
33 * MODULE: dapl_ring_buffer_util.c
34 *
35 * PURPOSE: Ring buffer management
36 * Description: Support and management functions for ring buffers
37 *
38 * $Id: dapl_ring_buffer_util.c,v 1.9 2003/07/08 14:23:35 sjs2 Exp $
39 */
40
41#include "dapl_ring_buffer_util.h"
42
43/*
44 * dapls_rbuf_alloc
45 *
46 * Given a DAPL_RING_BUFFER, initialize it and provide memory for
47 * the ringbuf itself. A passed in size will be adjusted to the next
48 * largest power of two number to simplify management.
49 *
50 * Input:
51 *	rbuf		pointer to DAPL_RING_BUFFER
52 *	size		number of elements to allocate & manage
53 *
54 * Output:
55 *	none
56 *
57 * Returns:
58 *	DAT_SUCCESS
59 *	DAT_INSUFFICIENT_RESOURCES
60 *
61 */
62DAT_RETURN
63dapls_rbuf_alloc(
64	INOUT	DAPL_RING_BUFFER	*rbuf,
65	IN	DAT_COUNT		 size)
66{
67	unsigned int			rsize;	/* real size */
68
69	/*
70	 * The circular buffer must be allocated one too large.
71	 * This eliminates any need for a distinct counter, as that
72	 * having the two pointers equal always means "empty" -- never "full"
73	 */
74	size++;
75
76	/* Put size on a power of 2 boundary */
77	rsize = 1;
78	while ((DAT_COUNT)rsize < size) {
79		rsize <<= 1;
80	}
81
82	rbuf->base = (void *) dapl_os_alloc(rsize * sizeof (void *));
83	if (rbuf->base != NULL) {
84		rbuf->lim = rsize - 1;
85		rbuf->head = 0;
86		rbuf->tail = 0;
87		dapl_os_lock_init(&rbuf->lock);
88	} else {
89		return (DAT_INSUFFICIENT_RESOURCES | DAT_RESOURCE_MEMORY);
90	}
91
92	return (DAT_SUCCESS);
93}
94
95
96/*
97 * dapls_rbuf_realloc
98 *
99 * Resizes an empty DAPL_RING_BUFFER. This function is not thread safe;
100 * adding or removing elements from a ring buffer while resizing
101 * will have indeterminate results.
102 *
103 * Input:
104 *	rbuf		pointer to DAPL_RING_BUFFER
105 *	size		number of elements to allocate & manage
106 *
107 * Output:
108 *	none
109 *
110 * Returns:
111 *	DAT_SUCCESS
112 *	DAT_INVALID_STATE
113 *	DAT_INSUFFICIENT_RESOURCES
114 *
115 */
116DAT_RETURN
117dapls_rbuf_realloc(
118	INOUT	DAPL_RING_BUFFER	*rbuf,
119	IN	DAT_COUNT		 size)
120{
121	int			rsize;		/* real size */
122	DAT_RETURN		dat_status;
123
124	dat_status = DAT_SUCCESS;
125
126	/* if the ring buffer is not empty */
127	if (rbuf->head != rbuf->tail) {
128		dat_status = DAT_ERROR(DAT_INVALID_STATE, 0);
129		goto bail;
130	}
131
132	/* Put size on a power of 2 boundary */
133	rsize = 1;
134	while (rsize < size) {
135		rsize <<= 1;
136	}
137
138	rbuf->base = (void *)dapl_os_realloc(rbuf->base,
139	    rsize * sizeof (void *));
140	if (NULL == rbuf->base) {
141		dat_status = DAT_ERROR(DAT_INSUFFICIENT_RESOURCES,
142		    DAT_RESOURCE_MEMORY);
143		goto bail;
144	}
145
146	rbuf->lim = rsize - 1;
147
148bail:
149	return (dat_status);
150}
151
152
153/*
154 * dapls_rbuf_destroy
155 *
156 * Release the buffer and reset pointers to a DAPL_RING_BUFFER
157 *
158 * Input:
159 *	rbuf		pointer to DAPL_RING_BUFFER
160 *
161 * Output:
162 *	none
163 *
164 * Returns:
165 *	none
166 *
167 */
168void
169dapls_rbuf_destroy(
170	IN  DAPL_RING_BUFFER		*rbuf)
171{
172	if ((NULL == rbuf) ||
173	    (NULL == rbuf->base)) {
174		return;
175	}
176
177	dapl_os_lock_destroy(&rbuf->lock);
178	dapl_os_free(rbuf->base, (rbuf->lim + 1) * sizeof (void *));
179	rbuf->base = NULL;
180	rbuf->lim = 0;
181}
182
183/*
184 * dapls_rbuf_add
185 *
186 * Add an entry to the ring buffer
187 *
188 * Input:
189 *	rbuf		pointer to DAPL_RING_BUFFER
190 *	entry		entry to add
191 *
192 * Output:
193 *	none
194 *
195 * Returns:
196 *	DAT_SUCCESS
197 *	DAT_INSUFFICIENT_RESOURCES         (queue full)
198 *
199 */
200DAT_RETURN
201dapls_rbuf_add(
202	IN  DAPL_RING_BUFFER		*rbuf,
203	IN  void			*entry)
204{
205	DAPL_ATOMIC		pos;
206
207	dapl_os_lock(&rbuf->lock);
208	pos = rbuf->head;
209	if (((pos + 1) & rbuf->lim) != rbuf->tail) {
210		rbuf->base[pos] = entry;
211		rbuf->head = (pos + 1) & rbuf->lim;
212		dapl_os_unlock(&rbuf->lock);
213		return (DAT_SUCCESS);
214	}
215
216	dapl_os_unlock(&rbuf->lock);
217	return (DAT_ERROR(DAT_INSUFFICIENT_RESOURCES, DAT_RESOURCE_MEMORY));
218}
219
220
221/*
222 * dapls_rbuf_remove
223 *
224 * Remove an entry from the ring buffer
225 *
226 * Input:
227 *	rbuf		pointer to DAPL_RING_BUFFER
228 *
229 * Output:
230 *	entry		entry removed from the ring buffer
231 *
232 * Returns:
233 *	a pointer to a buffer entry
234 */
235void *
236dapls_rbuf_remove(
237	IN  DAPL_RING_BUFFER	*rbuf)
238{
239	DAPL_ATOMIC		pos;
240
241	dapl_os_lock(&rbuf->lock);
242	if (rbuf->head != rbuf->tail) {
243		pos = rbuf->tail;
244		rbuf->tail = (pos + 1) & rbuf->lim;
245		dapl_os_unlock(&rbuf->lock);
246		return (rbuf->base[pos]);
247	}
248
249	dapl_os_unlock(&rbuf->lock);
250	return (NULL);
251}
252
253
254/*
255 * dapli_rbuf_count
256 *
257 * Return the number of entries in use in the ring buffer
258 *
259 * Input:
260 *	rbuf		pointer to DAPL_RING_BUFFER
261 *
262 * Output:
263 *	none
264 *
265 * Returns:
266 *	count of entries
267 *
268 */
269DAT_COUNT
270dapls_rbuf_count(
271	IN DAPL_RING_BUFFER *rbuf)
272{
273	int head;
274	int tail;
275
276	dapl_os_lock(&rbuf->lock);
277	head = rbuf->head;
278	tail = rbuf->tail;
279	dapl_os_unlock(&rbuf->lock);
280	if (head == tail)
281		return (0);
282	if (head > tail)
283		return (head - tail);
284	/* add 1 to lim as it is a mask, number of entries - 1 */
285	return ((rbuf->lim + 1 - tail + head));
286}
287