[ceph.git] / ceph / src / seastar / dpdk / lib / librte_cmdline / cmdline_cirbuf.c

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright(c) 2010-2014 Intel Corporation.
 * Copyright (c) 2009, Olivier MATZ <zer0@droids-corp.org>
 * All rights reserved.
 */

#include <string.h>
#include <errno.h>
#include <stdio.h>

#include "cmdline_cirbuf.h"


int
cirbuf_init(struct cirbuf *cbuf, char *buf, unsigned int start, unsigned int maxlen)
{
	if (!cbuf || !buf)
		return -EINVAL;
	cbuf->maxlen = maxlen;
	cbuf->len = 0;
	cbuf->start = start;
	cbuf->end = start;
	cbuf->buf = buf;
	return 0;
}

/* multiple add */

int
cirbuf_add_buf_head(struct cirbuf *cbuf, const char *c, unsigned int n)
{
	unsigned int e;

	if (!cbuf || !c || !n || n > CIRBUF_GET_FREELEN(cbuf))
		return -EINVAL;

	e = CIRBUF_IS_EMPTY(cbuf) ? 1 : 0;

	if (n < cbuf->start + e) {
		dprintf("s[%d] -> d[%d] (%d)\n", 0, cbuf->start - n + e, n);
		memcpy(cbuf->buf + cbuf->start - n + e, c, n);
	}
	else {
		dprintf("s[%d] -> d[%d] (%d)\n", + n - (cbuf->start + e), 0,
			cbuf->start + e);
		dprintf("s[%d] -> d[%d] (%d)\n", cbuf->maxlen - n +
			(cbuf->start + e), 0, n - (cbuf->start + e));
		memcpy(cbuf->buf, c  + n - (cbuf->start + e) , cbuf->start + e);
		memcpy(cbuf->buf + cbuf->maxlen - n + (cbuf->start + e), c,
		       n - (cbuf->start + e));
	}
	cbuf->len += n;
	cbuf->start += (cbuf->maxlen - n + e);
	cbuf->start %= cbuf->maxlen;
	return n;
}

/* multiple add */

int
cirbuf_add_buf_tail(struct cirbuf *cbuf, const char *c, unsigned int n)
{
	unsigned int e;

	if (!cbuf || !c || !n || n > CIRBUF_GET_FREELEN(cbuf))
		return -EINVAL;

	e = CIRBUF_IS_EMPTY(cbuf) ? 1 : 0;

	if (n < cbuf->maxlen - cbuf->end - 1 + e) {
		dprintf("s[%d] -> d[%d] (%d)\n", 0, cbuf->end + !e, n);
		memcpy(cbuf->buf + cbuf->end + !e, c, n);
	}
	else {
		dprintf("s[%d] -> d[%d] (%d)\n", cbuf->end + !e, 0,
			cbuf->maxlen - cbuf->end - 1 + e);
		dprintf("s[%d] -> d[%d] (%d)\n", cbuf->maxlen - cbuf->end - 1 +
			e, 0, n - cbuf->maxlen + cbuf->end + 1 - e);
		memcpy(cbuf->buf + cbuf->end + !e, c, cbuf->maxlen -
		       cbuf->end - 1 + e);
		memcpy(cbuf->buf, c + cbuf->maxlen - cbuf->end - 1 + e,
		       n - cbuf->maxlen + cbuf->end + 1 - e);
	}
	cbuf->len += n;
	cbuf->end += n - e;
	cbuf->end %= cbuf->maxlen;
	return n;
}

/* add at head */

static inline void
__cirbuf_add_head(struct cirbuf * cbuf, char c)
{
	if (!CIRBUF_IS_EMPTY(cbuf)) {
		cbuf->start += (cbuf->maxlen - 1);
		cbuf->start %= cbuf->maxlen;
	}
	cbuf->buf[cbuf->start] = c;
	cbuf->len ++;
}

int
cirbuf_add_head_safe(struct cirbuf * cbuf, char c)
{
	if (cbuf && !CIRBUF_IS_FULL(cbuf)) {
		__cirbuf_add_head(cbuf, c);
		return 0;
	}
	return -EINVAL;
}

void
cirbuf_add_head(struct cirbuf * cbuf, char c)
{
	__cirbuf_add_head(cbuf, c);
}

/* add at tail */

static inline void
__cirbuf_add_tail(struct cirbuf * cbuf, char c)
{
	if (!CIRBUF_IS_EMPTY(cbuf)) {
		cbuf->end ++;
		cbuf->end %= cbuf->maxlen;
	}
	cbuf->buf[cbuf->end] = c;
	cbuf->len ++;
}

int
cirbuf_add_tail_safe(struct cirbuf * cbuf, char c)
{
	if (cbuf && !CIRBUF_IS_FULL(cbuf)) {
		__cirbuf_add_tail(cbuf, c);
		return 0;
	}
	return -EINVAL;
}

void
cirbuf_add_tail(struct cirbuf * cbuf, char c)
{
	__cirbuf_add_tail(cbuf, c);
}


static inline void
__cirbuf_shift_left(struct cirbuf *cbuf)
{
	unsigned int i;
	char tmp = cbuf->buf[cbuf->start];

	for (i=0 ; i<cbuf->len ; i++) {
		cbuf->buf[(cbuf->start+i)%cbuf->maxlen] =
			cbuf->buf[(cbuf->start+i+1)%cbuf->maxlen];
	}
	cbuf->buf[(cbuf->start-1+cbuf->maxlen)%cbuf->maxlen] = tmp;
	cbuf->start += (cbuf->maxlen - 1);
	cbuf->start %= cbuf->maxlen;
	cbuf->end += (cbuf->maxlen - 1);
	cbuf->end %= cbuf->maxlen;
}

static inline void
__cirbuf_shift_right(struct cirbuf *cbuf)
{
	unsigned int i;
	char tmp = cbuf->buf[cbuf->end];

	for (i=0 ; i<cbuf->len ; i++) {
		cbuf->buf[(cbuf->end+cbuf->maxlen-i)%cbuf->maxlen] =
			cbuf->buf[(cbuf->end+cbuf->maxlen-i-1)%cbuf->maxlen];
	}
	cbuf->buf[(cbuf->end+1)%cbuf->maxlen] = tmp;
	cbuf->start += 1;
	cbuf->start %= cbuf->maxlen;
	cbuf->end += 1;
	cbuf->end %= cbuf->maxlen;
}

/* XXX we could do a better algorithm here... */
int
cirbuf_align_left(struct cirbuf * cbuf)
{
	if (!cbuf)
		return -EINVAL;

	if (cbuf->start < cbuf->maxlen/2) {
		while (cbuf->start != 0) {
			__cirbuf_shift_left(cbuf);
		}
	}
	else {
		while (cbuf->start != 0) {
			__cirbuf_shift_right(cbuf);
		}
	}

	return 0;
}

/* XXX we could do a better algorithm here... */
int
cirbuf_align_right(struct cirbuf * cbuf)
{
	if (!cbuf)
		return -EINVAL;

	if (cbuf->start >= cbuf->maxlen/2) {
		while (cbuf->end != cbuf->maxlen-1) {
			__cirbuf_shift_left(cbuf);
		}
	}
	else {
		while (cbuf->start != cbuf->maxlen-1) {
			__cirbuf_shift_right(cbuf);
		}
	}

	return 0;
}

/* buffer del */

int
cirbuf_del_buf_head(struct cirbuf *cbuf, unsigned int size)
{
	if (!cbuf || !size || size > CIRBUF_GET_LEN(cbuf))
		return -EINVAL;

	cbuf->len -= size;
	if (CIRBUF_IS_EMPTY(cbuf)) {
		cbuf->start += size - 1;
		cbuf->start %= cbuf->maxlen;
	}
	else {
		cbuf->start += size;
		cbuf->start %= cbuf->maxlen;
	}
	return 0;
}

/* buffer del */

int
cirbuf_del_buf_tail(struct cirbuf *cbuf, unsigned int size)
{
	if (!cbuf || !size || size > CIRBUF_GET_LEN(cbuf))
		return -EINVAL;

	cbuf->len -= size;
	if (CIRBUF_IS_EMPTY(cbuf)) {
		cbuf->end  += (cbuf->maxlen - size + 1);
		cbuf->end %= cbuf->maxlen;
	}
	else {
		cbuf->end  += (cbuf->maxlen - size);
		cbuf->end %= cbuf->maxlen;
	}
	return 0;
}

/* del at head */

static inline void
__cirbuf_del_head(struct cirbuf * cbuf)
{
	cbuf->len --;
	if (!CIRBUF_IS_EMPTY(cbuf)) {
		cbuf->start ++;
		cbuf->start %= cbuf->maxlen;
	}
}

int
cirbuf_del_head_safe(struct cirbuf * cbuf)
{
	if (cbuf && !CIRBUF_IS_EMPTY(cbuf)) {
		__cirbuf_del_head(cbuf);
		return 0;
	}
	return -EINVAL;
}

void
cirbuf_del_head(struct cirbuf * cbuf)
{
	__cirbuf_del_head(cbuf);
}

/* del at tail */

static inline void
__cirbuf_del_tail(struct cirbuf * cbuf)
{
	cbuf->len --;
	if (!CIRBUF_IS_EMPTY(cbuf)) {
		cbuf->end  += (cbuf->maxlen - 1);
		cbuf->end %= cbuf->maxlen;
	}
}

int
cirbuf_del_tail_safe(struct cirbuf * cbuf)
{
	if (cbuf && !CIRBUF_IS_EMPTY(cbuf)) {
		__cirbuf_del_tail(cbuf);
		return 0;
	}
	return -EINVAL;
}

void
cirbuf_del_tail(struct cirbuf * cbuf)
{
	__cirbuf_del_tail(cbuf);
}

/* convert to buffer */

int
cirbuf_get_buf_head(struct cirbuf *cbuf, char *c, unsigned int size)
{
	unsigned int n;

	if (!cbuf || !c)
		return -EINVAL;

	n = (size < CIRBUF_GET_LEN(cbuf)) ? size : CIRBUF_GET_LEN(cbuf);

	if (!n)
		return 0;

	if (cbuf->start <= cbuf->end) {
		dprintf("s[%d] -> d[%d] (%d)\n", cbuf->start, 0, n);
		memcpy(c, cbuf->buf + cbuf->start , n);
	}
	else {
		/* check if we need to go from end to the beginning */
		if (n <= cbuf->maxlen - cbuf->start) {
			dprintf("s[%d] -> d[%d] (%d)\n", 0, cbuf->start, n);
			memcpy(c, cbuf->buf + cbuf->start , n);
		}
		else {
			dprintf("s[%d] -> d[%d] (%d)\n", cbuf->start, 0,
				cbuf->maxlen - cbuf->start);
			dprintf("s[%d] -> d[%d] (%d)\n", 0, cbuf->maxlen - cbuf->start,
				n - cbuf->maxlen + cbuf->start);
			memcpy(c, cbuf->buf + cbuf->start , cbuf->maxlen - cbuf->start);
			memcpy(c + cbuf->maxlen - cbuf->start, cbuf->buf,
				   n - cbuf->maxlen + cbuf->start);
		}
	}
	return n;
}

/* convert to buffer */

int
cirbuf_get_buf_tail(struct cirbuf *cbuf, char *c, unsigned int size)
{
	unsigned int n;

	if (!cbuf || !c)
		return -EINVAL;

	n = (size < CIRBUF_GET_LEN(cbuf)) ? size : CIRBUF_GET_LEN(cbuf);

	if (!n)
		return 0;

	if (cbuf->start <= cbuf->end) {
		dprintf("s[%d] -> d[%d] (%d)\n", cbuf->end - n + 1, 0, n);
		memcpy(c, cbuf->buf + cbuf->end - n + 1, n);
	}
	else {
		/* check if we need to go from end to the beginning */
		if (n <= cbuf->end + 1) {
			dprintf("s[%d] -> d[%d] (%d)\n", 0, cbuf->end - n + 1, n);
			memcpy(c, cbuf->buf + cbuf->end - n + 1, n);
		}
		else {
			dprintf("s[%d] -> d[%d] (%d)\n", 0,
				cbuf->maxlen - cbuf->start, cbuf->end + 1);
			dprintf("s[%d] -> d[%d] (%d)\n",
				cbuf->maxlen - n + cbuf->end + 1, 0, n - cbuf->end - 1);
			memcpy(c + cbuf->maxlen - cbuf->start,
					       cbuf->buf, cbuf->end + 1);
			memcpy(c, cbuf->buf + cbuf->maxlen - n + cbuf->end +1,
				   n - cbuf->end - 1);
		}
	}
	return n;
}

/* get head or get tail */

char
cirbuf_get_head(struct cirbuf * cbuf)
{
	return cbuf->buf[cbuf->start];
}

/* get head or get tail */

char
cirbuf_get_tail(struct cirbuf * cbuf)
{
	return cbuf->buf[cbuf->end];
}
Commit	Line	Data
9f95a23c TL	1	/* SPDX-License-Identifier: BSD-3-Clause
9f95a23c TL	2	* Copyright(c) 2010-2014 Intel Corporation.
7c673cae FG	3	* Copyright (c) 2009, Olivier MATZ <zer0@droids-corp.org>
7c673cae FG	4	* All rights reserved.
7c673cae FG	5	*/
	6
	7	#include <string.h>
	8	#include <errno.h>
	9	#include <stdio.h>
	10
	11	#include "cmdline_cirbuf.h"
	12
	13
	14	int
	15	cirbuf_init(struct cirbuf cbuf, char buf, unsigned int start, unsigned int maxlen)
	16	{
	17	if (!cbuf \|\| !buf)
	18	return -EINVAL;
	19	cbuf->maxlen = maxlen;
	20	cbuf->len = 0;
	21	cbuf->start = start;
	22	cbuf->end = start;
	23	cbuf->buf = buf;
	24	return 0;
	25	}
	26
	27	/* multiple add */
	28
	29	int
	30	cirbuf_add_buf_head(struct cirbuf cbuf, const char c, unsigned int n)
	31	{
	32	unsigned int e;
	33
	34	if (!cbuf \|\| !c \|\| !n \|\| n > CIRBUF_GET_FREELEN(cbuf))
	35	return -EINVAL;
	36
	37	e = CIRBUF_IS_EMPTY(cbuf) ? 1 : 0;
	38
	39	if (n < cbuf->start + e) {
	40	dprintf("s[%d] -> d[%d] (%d)\n", 0, cbuf->start - n + e, n);
	41	memcpy(cbuf->buf + cbuf->start - n + e, c, n);
	42	}
	43	else {
	44	dprintf("s[%d] -> d[%d] (%d)\n", + n - (cbuf->start + e), 0,
	45	cbuf->start + e);
	46	dprintf("s[%d] -> d[%d] (%d)\n", cbuf->maxlen - n +
	47	(cbuf->start + e), 0, n - (cbuf->start + e));
	48	memcpy(cbuf->buf, c + n - (cbuf->start + e) , cbuf->start + e);
	49	memcpy(cbuf->buf + cbuf->maxlen - n + (cbuf->start + e), c,
	50	n - (cbuf->start + e));
	51	}
	52	cbuf->len += n;
	53	cbuf->start += (cbuf->maxlen - n + e);
	54	cbuf->start %= cbuf->maxlen;
	55	return n;
	56	}
	57
	58	/* multiple add */
	59
	60	int
	61	cirbuf_add_buf_tail(struct cirbuf cbuf, const char c, unsigned int n)
	62	{
	63	unsigned int e;
	64
	65	if (!cbuf \|\| !c \|\| !n \|\| n > CIRBUF_GET_FREELEN(cbuf))
	66	return -EINVAL;
	67
	68	e = CIRBUF_IS_EMPTY(cbuf) ? 1 : 0;
69
70	if (n < cbuf->maxlen - cbuf->end - 1 + e) {
71	dprintf("s[%d] -> d[%d] (%d)\n", 0, cbuf->end + !e, n);
72	memcpy(cbuf->buf + cbuf->end + !e, c, n);
73	}
74	else {
75	dprintf("s[%d] -> d[%d] (%d)\n", cbuf->end + !e, 0,
76	cbuf->maxlen - cbuf->end - 1 + e);
77	dprintf("s[%d] -> d[%d] (%d)\n", cbuf->maxlen - cbuf->end - 1 +
78	e, 0, n - cbuf->maxlen + cbuf->end + 1 - e);
79	memcpy(cbuf->buf + cbuf->end + !e, c, cbuf->maxlen -
80	cbuf->end - 1 + e);
81	memcpy(cbuf->buf, c + cbuf->maxlen - cbuf->end - 1 + e,
82	n - cbuf->maxlen + cbuf->end + 1 - e);
83	}
84	cbuf->len += n;
85	cbuf->end += n - e;
86	cbuf->end %= cbuf->maxlen;
87	return n;
88	}
89
90	/* add at head */
91
92	static inline void
93	__cirbuf_add_head(struct cirbuf * cbuf, char c)
94	{
95	if (!CIRBUF_IS_EMPTY(cbuf)) {
96	cbuf->start += (cbuf->maxlen - 1);
97	cbuf->start %= cbuf->maxlen;
98	}
99	cbuf->buf[cbuf->start] = c;
100	cbuf->len ++;
101	}
102
103	int
104	cirbuf_add_head_safe(struct cirbuf * cbuf, char c)
105	{
106	if (cbuf && !CIRBUF_IS_FULL(cbuf)) {
107	__cirbuf_add_head(cbuf, c);
108	return 0;
109	}
110	return -EINVAL;
111	}
112
113	void
114	cirbuf_add_head(struct cirbuf * cbuf, char c)
115	{
116	__cirbuf_add_head(cbuf, c);
117	}
118
119	/* add at tail */
120
121	static inline void
122	__cirbuf_add_tail(struct cirbuf * cbuf, char c)
123	{
124	if (!CIRBUF_IS_EMPTY(cbuf)) {
125	cbuf->end ++;
126	cbuf->end %= cbuf->maxlen;
127	}
128	cbuf->buf[cbuf->end] = c;
129	cbuf->len ++;
130	}
131
132	int
133	cirbuf_add_tail_safe(struct cirbuf * cbuf, char c)
134	{
135	if (cbuf && !CIRBUF_IS_FULL(cbuf)) {
136	__cirbuf_add_tail(cbuf, c);
137	return 0;
138	}
139	return -EINVAL;
140	}
141
142	void
143	cirbuf_add_tail(struct cirbuf * cbuf, char c)
144	{
145	__cirbuf_add_tail(cbuf, c);
146	}
147
148
149	static inline void
150	__cirbuf_shift_left(struct cirbuf *cbuf)
151	{
152	unsigned int i;
153	char tmp = cbuf->buf[cbuf->start];
154
155	for (i=0 ; i<cbuf->len ; i++) {
156	cbuf->buf[(cbuf->start+i)%cbuf->maxlen] =
157	cbuf->buf[(cbuf->start+i+1)%cbuf->maxlen];
158	}
159	cbuf->buf[(cbuf->start-1+cbuf->maxlen)%cbuf->maxlen] = tmp;
160	cbuf->start += (cbuf->maxlen - 1);
161	cbuf->start %= cbuf->maxlen;
162	cbuf->end += (cbuf->maxlen - 1);
163	cbuf->end %= cbuf->maxlen;
164	}
165
166	static inline void
167	__cirbuf_shift_right(struct cirbuf *cbuf)
168	{
169	unsigned int i;
170	char tmp = cbuf->buf[cbuf->end];
171
172	for (i=0 ; i<cbuf->len ; i++) {
173	cbuf->buf[(cbuf->end+cbuf->maxlen-i)%cbuf->maxlen] =
174	cbuf->buf[(cbuf->end+cbuf->maxlen-i-1)%cbuf->maxlen];
175	}
176	cbuf->buf[(cbuf->end+1)%cbuf->maxlen] = tmp;
177	cbuf->start += 1;
178	cbuf->start %= cbuf->maxlen;
179	cbuf->end += 1;
180	cbuf->end %= cbuf->maxlen;
181	}
182
183	/* XXX we could do a better algorithm here... */
184	int
185	cirbuf_align_left(struct cirbuf * cbuf)
186	{
187	if (!cbuf)
188	return -EINVAL;
189
190	if (cbuf->start < cbuf->maxlen/2) {
191	while (cbuf->start != 0) {
192	__cirbuf_shift_left(cbuf);
193	}
194	}
195	else {
196	while (cbuf->start != 0) {
197	__cirbuf_shift_right(cbuf);
198	}
199	}
200
201	return 0;
202	}
203
204	/* XXX we could do a better algorithm here... */
205	int
206	cirbuf_align_right(struct cirbuf * cbuf)
207	{
208	if (!cbuf)
209	return -EINVAL;
210
211	if (cbuf->start >= cbuf->maxlen/2) {
212	while (cbuf->end != cbuf->maxlen-1) {
213	__cirbuf_shift_left(cbuf);
214	}
215	}
216	else {
217	while (cbuf->start != cbuf->maxlen-1) {
218	__cirbuf_shift_right(cbuf);
219	}
220	}
221
222	return 0;
223	}
224
225	/* buffer del */
226
227	int
228	cirbuf_del_buf_head(struct cirbuf *cbuf, unsigned int size)
229	{
230	if (!cbuf \|\| !size \|\| size > CIRBUF_GET_LEN(cbuf))
231	return -EINVAL;
232
233	cbuf->len -= size;
234	if (CIRBUF_IS_EMPTY(cbuf)) {
235	cbuf->start += size - 1;
236	cbuf->start %= cbuf->maxlen;
237	}
238	else {
239	cbuf->start += size;
240	cbuf->start %= cbuf->maxlen;
241	}
242	return 0;
243	}
244
245	/* buffer del */
246
247	int
248	cirbuf_del_buf_tail(struct cirbuf *cbuf, unsigned int size)
249	{
250	if (!cbuf \|\| !size \|\| size > CIRBUF_GET_LEN(cbuf))
251	return -EINVAL;
252
253	cbuf->len -= size;
254	if (CIRBUF_IS_EMPTY(cbuf)) {
255	cbuf->end += (cbuf->maxlen - size + 1);
256	cbuf->end %= cbuf->maxlen;
257	}
258	else {
259	cbuf->end += (cbuf->maxlen - size);
260	cbuf->end %= cbuf->maxlen;
261	}
262	return 0;
263	}
264
265	/* del at head */
266
267	static inline void
268	__cirbuf_del_head(struct cirbuf * cbuf)
269	{
270	cbuf->len --;
271	if (!CIRBUF_IS_EMPTY(cbuf)) {
272	cbuf->start ++;
273	cbuf->start %= cbuf->maxlen;
274	}
275	}
276
277	int
278	cirbuf_del_head_safe(struct cirbuf * cbuf)
279	{
280	if (cbuf && !CIRBUF_IS_EMPTY(cbuf)) {
281	__cirbuf_del_head(cbuf);
282	return 0;
283	}
284	return -EINVAL;
285	}
286
287	void
288	cirbuf_del_head(struct cirbuf * cbuf)
289	{
290	__cirbuf_del_head(cbuf);
291	}
292
293	/* del at tail */
294
295	static inline void
296	__cirbuf_del_tail(struct cirbuf * cbuf)
297	{
298	cbuf->len --;
299	if (!CIRBUF_IS_EMPTY(cbuf)) {
300	cbuf->end += (cbuf->maxlen - 1);
301	cbuf->end %= cbuf->maxlen;
302	}
303	}
304
305	int
306	cirbuf_del_tail_safe(struct cirbuf * cbuf)
307	{
308	if (cbuf && !CIRBUF_IS_EMPTY(cbuf)) {
309	__cirbuf_del_tail(cbuf);
310	return 0;
311	}
312	return -EINVAL;
313	}
314
315	void
316	cirbuf_del_tail(struct cirbuf * cbuf)
317	{
318	__cirbuf_del_tail(cbuf);
319	}
320
321	/* convert to buffer */
322
323	int
324	cirbuf_get_buf_head(struct cirbuf cbuf, char c, unsigned int size)
325	{
326	unsigned int n;
327
328	if (!cbuf \|\| !c)
329	return -EINVAL;
330
331	n = (size < CIRBUF_GET_LEN(cbuf)) ? size : CIRBUF_GET_LEN(cbuf);
332
333	if (!n)
334	return 0;
335
336	if (cbuf->start <= cbuf->end) {
337	dprintf("s[%d] -> d[%d] (%d)\n", cbuf->start, 0, n);
338	memcpy(c, cbuf->buf + cbuf->start , n);
339	}
340	else {
341	/* check if we need to go from end to the beginning */
342	if (n <= cbuf->maxlen - cbuf->start) {
343	dprintf("s[%d] -> d[%d] (%d)\n", 0, cbuf->start, n);
344	memcpy(c, cbuf->buf + cbuf->start , n);
345	}
346	else {
347	dprintf("s[%d] -> d[%d] (%d)\n", cbuf->start, 0,
348	cbuf->maxlen - cbuf->start);
349	dprintf("s[%d] -> d[%d] (%d)\n", 0, cbuf->maxlen - cbuf->start,
350	n - cbuf->maxlen + cbuf->start);
351	memcpy(c, cbuf->buf + cbuf->start , cbuf->maxlen - cbuf->start);
352	memcpy(c + cbuf->maxlen - cbuf->start, cbuf->buf,
353	n - cbuf->maxlen + cbuf->start);
354	}
355	}
356	return n;
357	}
358
359	/* convert to buffer */
360
361	int
362	cirbuf_get_buf_tail(struct cirbuf cbuf, char c, unsigned int size)
363	{
364	unsigned int n;
365
366	if (!cbuf \|\| !c)
367	return -EINVAL;
368
369	n = (size < CIRBUF_GET_LEN(cbuf)) ? size : CIRBUF_GET_LEN(cbuf);
370
371	if (!n)
372	return 0;
373
374	if (cbuf->start <= cbuf->end) {
375	dprintf("s[%d] -> d[%d] (%d)\n", cbuf->end - n + 1, 0, n);
376	memcpy(c, cbuf->buf + cbuf->end - n + 1, n);
377	}
378	else {
379	/* check if we need to go from end to the beginning */
380	if (n <= cbuf->end + 1) {
381	dprintf("s[%d] -> d[%d] (%d)\n", 0, cbuf->end - n + 1, n);
382	memcpy(c, cbuf->buf + cbuf->end - n + 1, n);
383	}
384	else {
385	dprintf("s[%d] -> d[%d] (%d)\n", 0,
386	cbuf->maxlen - cbuf->start, cbuf->end + 1);
387	dprintf("s[%d] -> d[%d] (%d)\n",
388	cbuf->maxlen - n + cbuf->end + 1, 0, n - cbuf->end - 1);
389	memcpy(c + cbuf->maxlen - cbuf->start,
390	cbuf->buf, cbuf->end + 1);
391	memcpy(c, cbuf->buf + cbuf->maxlen - n + cbuf->end +1,
392	n - cbuf->end - 1);
393	}
394	}
395	return n;
396	}
397
398	/* get head or get tail */
399
400	char
401	cirbuf_get_head(struct cirbuf * cbuf)
402	{
403	return cbuf->buf[cbuf->start];
404	}
405
406	/* get head or get tail */
407
408	char
409	cirbuf_get_tail(struct cirbuf * cbuf)
410	{
411	return cbuf->buf[cbuf->end];
412	}