test_mbuf.c revision 809f0800
1/*-
2 *   BSD LICENSE
3 *
4 *   Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
5 *   All rights reserved.
6 *
7 *   Redistribution and use in source and binary forms, with or without
8 *   modification, are permitted provided that the following conditions
9 *   are met:
10 *
11 *     * Redistributions of source code must retain the above copyright
12 *       notice, this list of conditions and the following disclaimer.
13 *     * Redistributions in binary form must reproduce the above copyright
14 *       notice, this list of conditions and the following disclaimer in
15 *       the documentation and/or other materials provided with the
16 *       distribution.
17 *     * Neither the name of Intel Corporation nor the names of its
18 *       contributors may be used to endorse or promote products derived
19 *       from this software without specific prior written permission.
20 *
21 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34#include <string.h>
35#include <stdarg.h>
36#include <stdio.h>
37#include <stdlib.h>
38#include <stdint.h>
39#include <inttypes.h>
40#include <errno.h>
41#include <sys/queue.h>
42
43#include <rte_common.h>
44#include <rte_debug.h>
45#include <rte_log.h>
46#include <rte_common.h>
47#include <rte_memory.h>
48#include <rte_memcpy.h>
49#include <rte_memzone.h>
50#include <rte_launch.h>
51#include <rte_eal.h>
52#include <rte_per_lcore.h>
53#include <rte_lcore.h>
54#include <rte_atomic.h>
55#include <rte_branch_prediction.h>
56#include <rte_ring.h>
57#include <rte_mempool.h>
58#include <rte_mbuf.h>
59#include <rte_random.h>
60#include <rte_cycles.h>
61
62#include "test.h"
63
64#define MBUF_DATA_SIZE          2048
65#define NB_MBUF                 128
66#define MBUF_TEST_DATA_LEN      1464
67#define MBUF_TEST_DATA_LEN2     50
68#define MBUF_TEST_HDR1_LEN      20
69#define MBUF_TEST_HDR2_LEN      30
70#define MBUF_TEST_ALL_HDRS_LEN  (MBUF_TEST_HDR1_LEN+MBUF_TEST_HDR2_LEN)
71
72/* size of private data for mbuf in pktmbuf_pool2 */
73#define MBUF2_PRIV_SIZE         128
74
75#define REFCNT_MAX_ITER         64
76#define REFCNT_MAX_TIMEOUT      10
77#define REFCNT_MAX_REF          (RTE_MAX_LCORE)
78#define REFCNT_MBUF_NUM         64
79#define REFCNT_RING_SIZE        (REFCNT_MBUF_NUM * REFCNT_MAX_REF)
80
81#define MAGIC_DATA              0x42424242
82
83#define MAKE_STRING(x)          # x
84
85static struct rte_mempool *pktmbuf_pool = NULL;
86static struct rte_mempool *pktmbuf_pool2 = NULL;
87
88#ifdef RTE_MBUF_REFCNT_ATOMIC
89
90static struct rte_mempool *refcnt_pool = NULL;
91static struct rte_ring *refcnt_mbuf_ring = NULL;
92static volatile uint32_t refcnt_stop_slaves;
93static unsigned refcnt_lcore[RTE_MAX_LCORE];
94
95#endif
96
97/*
98 * MBUF
99 * ====
100 *
101 * #. Allocate a mbuf pool.
102 *
103 *    - The pool contains NB_MBUF elements, where each mbuf is MBUF_SIZE
104 *      bytes long.
105 *
106 * #. Test multiple allocations of mbufs from this pool.
107 *
108 *    - Allocate NB_MBUF and store pointers in a table.
109 *    - If an allocation fails, return an error.
110 *    - Free all these mbufs.
111 *    - Repeat the same test to check that mbufs were freed correctly.
112 *
113 * #. Test data manipulation in pktmbuf.
114 *
115 *    - Alloc an mbuf.
116 *    - Append data using rte_pktmbuf_append().
117 *    - Test for error in rte_pktmbuf_append() when len is too large.
118 *    - Trim data at the end of mbuf using rte_pktmbuf_trim().
119 *    - Test for error in rte_pktmbuf_trim() when len is too large.
120 *    - Prepend a header using rte_pktmbuf_prepend().
121 *    - Test for error in rte_pktmbuf_prepend() when len is too large.
122 *    - Remove data at the beginning of mbuf using rte_pktmbuf_adj().
123 *    - Test for error in rte_pktmbuf_adj() when len is too large.
124 *    - Check that appended data is not corrupt.
125 *    - Free the mbuf.
126 *    - Between all these tests, check data_len and pkt_len, and
127 *      that the mbuf is contiguous.
128 *    - Repeat the test to check that allocation operations
129 *      reinitialize the mbuf correctly.
130 *
131 * #. Test packet cloning
132 *    - Clone a mbuf and verify the data
133 *    - Clone the cloned mbuf and verify the data
134 *    - Attach a mbuf to another that does not have the same priv_size.
135 */
136
137#define GOTO_FAIL(str, ...) do {					\
138		printf("mbuf test FAILED (l.%d): <" str ">\n",		\
139		       __LINE__,  ##__VA_ARGS__);			\
140		goto fail;						\
141} while(0)
142
143/*
144 * test data manipulation in mbuf with non-ascii data
145 */
146static int
147test_pktmbuf_with_non_ascii_data(void)
148{
149	struct rte_mbuf *m = NULL;
150	char *data;
151
152	m = rte_pktmbuf_alloc(pktmbuf_pool);
153	if (m == NULL)
154		GOTO_FAIL("Cannot allocate mbuf");
155	if (rte_pktmbuf_pkt_len(m) != 0)
156		GOTO_FAIL("Bad length");
157
158	data = rte_pktmbuf_append(m, MBUF_TEST_DATA_LEN);
159	if (data == NULL)
160		GOTO_FAIL("Cannot append data");
161	if (rte_pktmbuf_pkt_len(m) != MBUF_TEST_DATA_LEN)
162		GOTO_FAIL("Bad pkt length");
163	if (rte_pktmbuf_data_len(m) != MBUF_TEST_DATA_LEN)
164		GOTO_FAIL("Bad data length");
165	memset(data, 0xff, rte_pktmbuf_pkt_len(m));
166	if (!rte_pktmbuf_is_contiguous(m))
167		GOTO_FAIL("Buffer should be continuous");
168	rte_pktmbuf_dump(stdout, m, MBUF_TEST_DATA_LEN);
169
170	rte_pktmbuf_free(m);
171
172	return 0;
173
174fail:
175	if(m) {
176		rte_pktmbuf_free(m);
177	}
178	return -1;
179}
180
181/*
182 * test data manipulation in mbuf
183 */
184static int
185test_one_pktmbuf(void)
186{
187	struct rte_mbuf *m = NULL;
188	char *data, *data2, *hdr;
189	unsigned i;
190
191	printf("Test pktmbuf API\n");
192
193	/* alloc a mbuf */
194
195	m = rte_pktmbuf_alloc(pktmbuf_pool);
196	if (m == NULL)
197		GOTO_FAIL("Cannot allocate mbuf");
198	if (rte_pktmbuf_pkt_len(m) != 0)
199		GOTO_FAIL("Bad length");
200
201	rte_pktmbuf_dump(stdout, m, 0);
202
203	/* append data */
204
205	data = rte_pktmbuf_append(m, MBUF_TEST_DATA_LEN);
206	if (data == NULL)
207		GOTO_FAIL("Cannot append data");
208	if (rte_pktmbuf_pkt_len(m) != MBUF_TEST_DATA_LEN)
209		GOTO_FAIL("Bad pkt length");
210	if (rte_pktmbuf_data_len(m) != MBUF_TEST_DATA_LEN)
211		GOTO_FAIL("Bad data length");
212	memset(data, 0x66, rte_pktmbuf_pkt_len(m));
213	if (!rte_pktmbuf_is_contiguous(m))
214		GOTO_FAIL("Buffer should be continuous");
215	rte_pktmbuf_dump(stdout, m, MBUF_TEST_DATA_LEN);
216	rte_pktmbuf_dump(stdout, m, 2*MBUF_TEST_DATA_LEN);
217
218	/* this append should fail */
219
220	data2 = rte_pktmbuf_append(m, (uint16_t)(rte_pktmbuf_tailroom(m) + 1));
221	if (data2 != NULL)
222		GOTO_FAIL("Append should not succeed");
223
224	/* append some more data */
225
226	data2 = rte_pktmbuf_append(m, MBUF_TEST_DATA_LEN2);
227	if (data2 == NULL)
228		GOTO_FAIL("Cannot append data");
229	if (rte_pktmbuf_pkt_len(m) != MBUF_TEST_DATA_LEN + MBUF_TEST_DATA_LEN2)
230		GOTO_FAIL("Bad pkt length");
231	if (rte_pktmbuf_data_len(m) != MBUF_TEST_DATA_LEN + MBUF_TEST_DATA_LEN2)
232		GOTO_FAIL("Bad data length");
233	if (!rte_pktmbuf_is_contiguous(m))
234		GOTO_FAIL("Buffer should be continuous");
235
236	/* trim data at the end of mbuf */
237
238	if (rte_pktmbuf_trim(m, MBUF_TEST_DATA_LEN2) < 0)
239		GOTO_FAIL("Cannot trim data");
240	if (rte_pktmbuf_pkt_len(m) != MBUF_TEST_DATA_LEN)
241		GOTO_FAIL("Bad pkt length");
242	if (rte_pktmbuf_data_len(m) != MBUF_TEST_DATA_LEN)
243		GOTO_FAIL("Bad data length");
244	if (!rte_pktmbuf_is_contiguous(m))
245		GOTO_FAIL("Buffer should be continuous");
246
247	/* this trim should fail */
248
249	if (rte_pktmbuf_trim(m, (uint16_t)(rte_pktmbuf_data_len(m) + 1)) == 0)
250		GOTO_FAIL("trim should not succeed");
251
252	/* prepend one header */
253
254	hdr = rte_pktmbuf_prepend(m, MBUF_TEST_HDR1_LEN);
255	if (hdr == NULL)
256		GOTO_FAIL("Cannot prepend");
257	if (data - hdr != MBUF_TEST_HDR1_LEN)
258		GOTO_FAIL("Prepend failed");
259	if (rte_pktmbuf_pkt_len(m) != MBUF_TEST_DATA_LEN + MBUF_TEST_HDR1_LEN)
260		GOTO_FAIL("Bad pkt length");
261	if (rte_pktmbuf_data_len(m) != MBUF_TEST_DATA_LEN + MBUF_TEST_HDR1_LEN)
262		GOTO_FAIL("Bad data length");
263	if (!rte_pktmbuf_is_contiguous(m))
264		GOTO_FAIL("Buffer should be continuous");
265	memset(hdr, 0x55, MBUF_TEST_HDR1_LEN);
266
267	/* prepend another header */
268
269	hdr = rte_pktmbuf_prepend(m, MBUF_TEST_HDR2_LEN);
270	if (hdr == NULL)
271		GOTO_FAIL("Cannot prepend");
272	if (data - hdr != MBUF_TEST_ALL_HDRS_LEN)
273		GOTO_FAIL("Prepend failed");
274	if (rte_pktmbuf_pkt_len(m) != MBUF_TEST_DATA_LEN + MBUF_TEST_ALL_HDRS_LEN)
275		GOTO_FAIL("Bad pkt length");
276	if (rte_pktmbuf_data_len(m) != MBUF_TEST_DATA_LEN + MBUF_TEST_ALL_HDRS_LEN)
277		GOTO_FAIL("Bad data length");
278	if (!rte_pktmbuf_is_contiguous(m))
279		GOTO_FAIL("Buffer should be continuous");
280	memset(hdr, 0x55, MBUF_TEST_HDR2_LEN);
281
282	rte_mbuf_sanity_check(m, 1);
283	rte_mbuf_sanity_check(m, 0);
284	rte_pktmbuf_dump(stdout, m, 0);
285
286	/* this prepend should fail */
287
288	hdr = rte_pktmbuf_prepend(m, (uint16_t)(rte_pktmbuf_headroom(m) + 1));
289	if (hdr != NULL)
290		GOTO_FAIL("prepend should not succeed");
291
292	/* remove data at beginning of mbuf (adj) */
293
294	if (data != rte_pktmbuf_adj(m, MBUF_TEST_ALL_HDRS_LEN))
295		GOTO_FAIL("rte_pktmbuf_adj failed");
296	if (rte_pktmbuf_pkt_len(m) != MBUF_TEST_DATA_LEN)
297		GOTO_FAIL("Bad pkt length");
298	if (rte_pktmbuf_data_len(m) != MBUF_TEST_DATA_LEN)
299		GOTO_FAIL("Bad data length");
300	if (!rte_pktmbuf_is_contiguous(m))
301		GOTO_FAIL("Buffer should be continuous");
302
303	/* this adj should fail */
304
305	if (rte_pktmbuf_adj(m, (uint16_t)(rte_pktmbuf_data_len(m) + 1)) != NULL)
306		GOTO_FAIL("rte_pktmbuf_adj should not succeed");
307
308	/* check data */
309
310	if (!rte_pktmbuf_is_contiguous(m))
311		GOTO_FAIL("Buffer should be continuous");
312
313	for (i=0; i<MBUF_TEST_DATA_LEN; i++) {
314		if (data[i] != 0x66)
315			GOTO_FAIL("Data corrupted at offset %u", i);
316	}
317
318	/* free mbuf */
319
320	rte_pktmbuf_free(m);
321	m = NULL;
322	return 0;
323
324fail:
325	if (m)
326		rte_pktmbuf_free(m);
327	return -1;
328}
329
330static int
331testclone_testupdate_testdetach(void)
332{
333	struct rte_mbuf *m = NULL;
334	struct rte_mbuf *clone = NULL;
335	struct rte_mbuf *clone2 = NULL;
336	unaligned_uint32_t *data;
337
338	/* alloc a mbuf */
339	m = rte_pktmbuf_alloc(pktmbuf_pool);
340	if (m == NULL)
341		GOTO_FAIL("ooops not allocating mbuf");
342
343	if (rte_pktmbuf_pkt_len(m) != 0)
344		GOTO_FAIL("Bad length");
345
346	rte_pktmbuf_append(m, sizeof(uint32_t));
347	data = rte_pktmbuf_mtod(m, unaligned_uint32_t *);
348	*data = MAGIC_DATA;
349
350	/* clone the allocated mbuf */
351	clone = rte_pktmbuf_clone(m, pktmbuf_pool);
352	if (clone == NULL)
353		GOTO_FAIL("cannot clone data\n");
354
355	data = rte_pktmbuf_mtod(clone, unaligned_uint32_t *);
356	if (*data != MAGIC_DATA)
357		GOTO_FAIL("invalid data in clone\n");
358
359	if (rte_mbuf_refcnt_read(m) != 2)
360		GOTO_FAIL("invalid refcnt in m\n");
361
362	/* free the clone */
363	rte_pktmbuf_free(clone);
364	clone = NULL;
365
366	/* same test with a chained mbuf */
367	m->next = rte_pktmbuf_alloc(pktmbuf_pool);
368	if (m->next == NULL)
369		GOTO_FAIL("Next Pkt Null\n");
370
371	rte_pktmbuf_append(m->next, sizeof(uint32_t));
372	data = rte_pktmbuf_mtod(m->next, unaligned_uint32_t *);
373	*data = MAGIC_DATA;
374
375	clone = rte_pktmbuf_clone(m, pktmbuf_pool);
376	if (clone == NULL)
377		GOTO_FAIL("cannot clone data\n");
378
379	data = rte_pktmbuf_mtod(clone, unaligned_uint32_t *);
380	if (*data != MAGIC_DATA)
381		GOTO_FAIL("invalid data in clone\n");
382
383	data = rte_pktmbuf_mtod(clone->next, unaligned_uint32_t *);
384	if (*data != MAGIC_DATA)
385		GOTO_FAIL("invalid data in clone->next\n");
386
387	if (rte_mbuf_refcnt_read(m) != 2)
388		GOTO_FAIL("invalid refcnt in m\n");
389
390	if (rte_mbuf_refcnt_read(m->next) != 2)
391		GOTO_FAIL("invalid refcnt in m->next\n");
392
393	/* try to clone the clone */
394
395	clone2 = rte_pktmbuf_clone(clone, pktmbuf_pool);
396	if (clone2 == NULL)
397		GOTO_FAIL("cannot clone the clone\n");
398
399	data = rte_pktmbuf_mtod(clone2, unaligned_uint32_t *);
400	if (*data != MAGIC_DATA)
401		GOTO_FAIL("invalid data in clone2\n");
402
403	data = rte_pktmbuf_mtod(clone2->next, unaligned_uint32_t *);
404	if (*data != MAGIC_DATA)
405		GOTO_FAIL("invalid data in clone2->next\n");
406
407	if (rte_mbuf_refcnt_read(m) != 3)
408		GOTO_FAIL("invalid refcnt in m\n");
409
410	if (rte_mbuf_refcnt_read(m->next) != 3)
411		GOTO_FAIL("invalid refcnt in m->next\n");
412
413	/* free mbuf */
414	rte_pktmbuf_free(m);
415	rte_pktmbuf_free(clone);
416	rte_pktmbuf_free(clone2);
417
418	m = NULL;
419	clone = NULL;
420	clone2 = NULL;
421	printf("%s ok\n", __func__);
422	return 0;
423
424fail:
425	if (m)
426		rte_pktmbuf_free(m);
427	if (clone)
428		rte_pktmbuf_free(clone);
429	if (clone2)
430		rte_pktmbuf_free(clone2);
431	return -1;
432}
433
434static int
435test_attach_from_different_pool(void)
436{
437	struct rte_mbuf *m = NULL;
438	struct rte_mbuf *clone = NULL;
439	struct rte_mbuf *clone2 = NULL;
440	char *data, *c_data, *c_data2;
441
442	/* alloc a mbuf */
443	m = rte_pktmbuf_alloc(pktmbuf_pool);
444	if (m == NULL)
445		GOTO_FAIL("cannot allocate mbuf");
446
447	if (rte_pktmbuf_pkt_len(m) != 0)
448		GOTO_FAIL("Bad length");
449
450	data = rte_pktmbuf_mtod(m, char *);
451
452	/* allocate a new mbuf from the second pool, and attach it to the first
453	 * mbuf */
454	clone = rte_pktmbuf_alloc(pktmbuf_pool2);
455	if (clone == NULL)
456		GOTO_FAIL("cannot allocate mbuf from second pool\n");
457
458	/* check data room size and priv size, and erase priv */
459	if (rte_pktmbuf_data_room_size(clone->pool) != 0)
460		GOTO_FAIL("data room size should be 0\n");
461	if (rte_pktmbuf_priv_size(clone->pool) != MBUF2_PRIV_SIZE)
462		GOTO_FAIL("data room size should be %d\n", MBUF2_PRIV_SIZE);
463	memset(clone + 1, 0, MBUF2_PRIV_SIZE);
464
465	/* save data pointer to compare it after detach() */
466	c_data = rte_pktmbuf_mtod(clone, char *);
467	if (c_data != (char *)clone + sizeof(*clone) + MBUF2_PRIV_SIZE)
468		GOTO_FAIL("bad data pointer in clone");
469	if (rte_pktmbuf_headroom(clone) != 0)
470		GOTO_FAIL("bad headroom in clone");
471
472	rte_pktmbuf_attach(clone, m);
473
474	if (rte_pktmbuf_mtod(clone, char *) != data)
475		GOTO_FAIL("clone was not attached properly\n");
476	if (rte_pktmbuf_headroom(clone) != RTE_PKTMBUF_HEADROOM)
477		GOTO_FAIL("bad headroom in clone after attach");
478	if (rte_mbuf_refcnt_read(m) != 2)
479		GOTO_FAIL("invalid refcnt in m\n");
480
481	/* allocate a new mbuf from the second pool, and attach it to the first
482	 * cloned mbuf */
483	clone2 = rte_pktmbuf_alloc(pktmbuf_pool2);
484	if (clone2 == NULL)
485		GOTO_FAIL("cannot allocate clone2 from second pool\n");
486
487	/* check data room size and priv size, and erase priv */
488	if (rte_pktmbuf_data_room_size(clone2->pool) != 0)
489		GOTO_FAIL("data room size should be 0\n");
490	if (rte_pktmbuf_priv_size(clone2->pool) != MBUF2_PRIV_SIZE)
491		GOTO_FAIL("data room size should be %d\n", MBUF2_PRIV_SIZE);
492	memset(clone2 + 1, 0, MBUF2_PRIV_SIZE);
493
494	/* save data pointer to compare it after detach() */
495	c_data2 = rte_pktmbuf_mtod(clone2, char *);
496	if (c_data2 != (char *)clone2 + sizeof(*clone2) + MBUF2_PRIV_SIZE)
497		GOTO_FAIL("bad data pointer in clone2");
498	if (rte_pktmbuf_headroom(clone2) != 0)
499		GOTO_FAIL("bad headroom in clone2");
500
501	rte_pktmbuf_attach(clone2, clone);
502
503	if (rte_pktmbuf_mtod(clone2, char *) != data)
504		GOTO_FAIL("clone2 was not attached properly\n");
505	if (rte_pktmbuf_headroom(clone2) != RTE_PKTMBUF_HEADROOM)
506		GOTO_FAIL("bad headroom in clone2 after attach");
507	if (rte_mbuf_refcnt_read(m) != 3)
508		GOTO_FAIL("invalid refcnt in m\n");
509
510	/* detach the clones */
511	rte_pktmbuf_detach(clone);
512	if (c_data != rte_pktmbuf_mtod(clone, char *))
513		GOTO_FAIL("clone was not detached properly\n");
514	if (rte_mbuf_refcnt_read(m) != 2)
515		GOTO_FAIL("invalid refcnt in m\n");
516
517	rte_pktmbuf_detach(clone2);
518	if (c_data2 != rte_pktmbuf_mtod(clone2, char *))
519		GOTO_FAIL("clone2 was not detached properly\n");
520	if (rte_mbuf_refcnt_read(m) != 1)
521		GOTO_FAIL("invalid refcnt in m\n");
522
523	/* free the clones and the initial mbuf */
524	rte_pktmbuf_free(clone2);
525	rte_pktmbuf_free(clone);
526	rte_pktmbuf_free(m);
527	printf("%s ok\n", __func__);
528	return 0;
529
530fail:
531	if (m)
532		rte_pktmbuf_free(m);
533	if (clone)
534		rte_pktmbuf_free(clone);
535	if (clone2)
536		rte_pktmbuf_free(clone2);
537	return -1;
538}
539#undef GOTO_FAIL
540
541/*
542 * test allocation and free of mbufs
543 */
544static int
545test_pktmbuf_pool(void)
546{
547	unsigned i;
548	struct rte_mbuf *m[NB_MBUF];
549	int ret = 0;
550
551	for (i=0; i<NB_MBUF; i++)
552		m[i] = NULL;
553
554	/* alloc NB_MBUF mbufs */
555	for (i=0; i<NB_MBUF; i++) {
556		m[i] = rte_pktmbuf_alloc(pktmbuf_pool);
557		if (m[i] == NULL) {
558			printf("rte_pktmbuf_alloc() failed (%u)\n", i);
559			ret = -1;
560		}
561	}
562	struct rte_mbuf *extra = NULL;
563	extra = rte_pktmbuf_alloc(pktmbuf_pool);
564	if(extra != NULL) {
565		printf("Error pool not empty");
566		ret = -1;
567	}
568	extra = rte_pktmbuf_clone(m[0], pktmbuf_pool);
569	if(extra != NULL) {
570		printf("Error pool not empty");
571		ret = -1;
572	}
573	/* free them */
574	for (i=0; i<NB_MBUF; i++) {
575		if (m[i] != NULL)
576			rte_pktmbuf_free(m[i]);
577	}
578
579	return ret;
580}
581
582/*
583 * test that the pointer to the data on a packet mbuf is set properly
584 */
585static int
586test_pktmbuf_pool_ptr(void)
587{
588	unsigned i;
589	struct rte_mbuf *m[NB_MBUF];
590	int ret = 0;
591
592	for (i=0; i<NB_MBUF; i++)
593		m[i] = NULL;
594
595	/* alloc NB_MBUF mbufs */
596	for (i=0; i<NB_MBUF; i++) {
597		m[i] = rte_pktmbuf_alloc(pktmbuf_pool);
598		if (m[i] == NULL) {
599			printf("rte_pktmbuf_alloc() failed (%u)\n", i);
600			ret = -1;
601			break;
602		}
603		m[i]->data_off += 64;
604	}
605
606	/* free them */
607	for (i=0; i<NB_MBUF; i++) {
608		if (m[i] != NULL)
609			rte_pktmbuf_free(m[i]);
610	}
611
612	for (i=0; i<NB_MBUF; i++)
613		m[i] = NULL;
614
615	/* alloc NB_MBUF mbufs */
616	for (i=0; i<NB_MBUF; i++) {
617		m[i] = rte_pktmbuf_alloc(pktmbuf_pool);
618		if (m[i] == NULL) {
619			printf("rte_pktmbuf_alloc() failed (%u)\n", i);
620			ret = -1;
621			break;
622		}
623		if (m[i]->data_off != RTE_PKTMBUF_HEADROOM) {
624			printf("invalid data_off\n");
625			ret = -1;
626		}
627	}
628
629	/* free them */
630	for (i=0; i<NB_MBUF; i++) {
631		if (m[i] != NULL)
632			rte_pktmbuf_free(m[i]);
633	}
634
635	return ret;
636}
637
638static int
639test_pktmbuf_free_segment(void)
640{
641	unsigned i;
642	struct rte_mbuf *m[NB_MBUF];
643	int ret = 0;
644
645	for (i=0; i<NB_MBUF; i++)
646		m[i] = NULL;
647
648	/* alloc NB_MBUF mbufs */
649	for (i=0; i<NB_MBUF; i++) {
650		m[i] = rte_pktmbuf_alloc(pktmbuf_pool);
651		if (m[i] == NULL) {
652			printf("rte_pktmbuf_alloc() failed (%u)\n", i);
653			ret = -1;
654		}
655	}
656
657	/* free them */
658	for (i=0; i<NB_MBUF; i++) {
659		if (m[i] != NULL) {
660			struct rte_mbuf *mb, *mt;
661
662			mb = m[i];
663			while(mb != NULL) {
664				mt = mb;
665				mb = mb->next;
666				rte_pktmbuf_free_seg(mt);
667			}
668		}
669	}
670
671	return ret;
672}
673
674/*
675 * Stress test for rte_mbuf atomic refcnt.
676 * Implies that RTE_MBUF_REFCNT_ATOMIC is defined.
677 * For more efficency, recomended to run with RTE_LIBRTE_MBUF_DEBUG defined.
678 */
679
680#ifdef RTE_MBUF_REFCNT_ATOMIC
681
682static int
683test_refcnt_slave(__attribute__((unused)) void *arg)
684{
685	unsigned lcore, free;
686	void *mp = 0;
687
688	lcore = rte_lcore_id();
689	printf("%s started at lcore %u\n", __func__, lcore);
690
691	free = 0;
692	while (refcnt_stop_slaves == 0) {
693		if (rte_ring_dequeue(refcnt_mbuf_ring, &mp) == 0) {
694			free++;
695			rte_pktmbuf_free((struct rte_mbuf *)mp);
696		}
697	}
698
699	refcnt_lcore[lcore] += free;
700	printf("%s finished at lcore %u, "
701	       "number of freed mbufs: %u\n",
702	       __func__, lcore, free);
703	return 0;
704}
705
706static void
707test_refcnt_iter(unsigned lcore, unsigned iter)
708{
709	uint16_t ref;
710	unsigned i, n, tref, wn;
711	struct rte_mbuf *m;
712
713	tref = 0;
714
715	/* For each mbuf in the pool:
716	 * - allocate mbuf,
717	 * - increment it's reference up to N+1,
718	 * - enqueue it N times into the ring for slave cores to free.
719	 */
720	for (i = 0, n = rte_mempool_avail_count(refcnt_pool);
721	    i != n && (m = rte_pktmbuf_alloc(refcnt_pool)) != NULL;
722	    i++) {
723		ref = RTE_MAX(rte_rand() % REFCNT_MAX_REF, 1UL);
724		tref += ref;
725		if ((ref & 1) != 0) {
726			rte_pktmbuf_refcnt_update(m, ref);
727			while (ref-- != 0)
728				rte_ring_enqueue(refcnt_mbuf_ring, m);
729		} else {
730			while (ref-- != 0) {
731				rte_pktmbuf_refcnt_update(m, 1);
732				rte_ring_enqueue(refcnt_mbuf_ring, m);
733			}
734		}
735		rte_pktmbuf_free(m);
736	}
737
738	if (i != n)
739		rte_panic("(lcore=%u, iter=%u): was able to allocate only "
740		          "%u from %u mbufs\n", lcore, iter, i, n);
741
742	/* wait till slave lcores  will consume all mbufs */
743	while (!rte_ring_empty(refcnt_mbuf_ring))
744		;
745
746	/* check that all mbufs are back into mempool by now */
747	for (wn = 0; wn != REFCNT_MAX_TIMEOUT; wn++) {
748		if ((i = rte_mempool_avail_count(refcnt_pool)) == n) {
749			refcnt_lcore[lcore] += tref;
750			printf("%s(lcore=%u, iter=%u) completed, "
751			    "%u references processed\n",
752			    __func__, lcore, iter, tref);
753			return;
754		}
755		rte_delay_ms(100);
756	}
757
758	rte_panic("(lcore=%u, iter=%u): after %us only "
759	          "%u of %u mbufs left free\n", lcore, iter, wn, i, n);
760}
761
762static int
763test_refcnt_master(void)
764{
765	unsigned i, lcore;
766
767	lcore = rte_lcore_id();
768	printf("%s started at lcore %u\n", __func__, lcore);
769
770	for (i = 0; i != REFCNT_MAX_ITER; i++)
771		test_refcnt_iter(lcore, i);
772
773	refcnt_stop_slaves = 1;
774	rte_wmb();
775
776	printf("%s finished at lcore %u\n", __func__, lcore);
777	return 0;
778}
779
780#endif
781
782static int
783test_refcnt_mbuf(void)
784{
785#ifdef RTE_MBUF_REFCNT_ATOMIC
786
787	unsigned lnum, master, slave, tref;
788
789
790	if ((lnum = rte_lcore_count()) == 1) {
791		printf("skipping %s, number of lcores: %u is not enough\n",
792		    __func__, lnum);
793		return 0;
794	}
795
796	printf("starting %s, at %u lcores\n", __func__, lnum);
797
798	/* create refcnt pool & ring if they don't exist */
799
800	if (refcnt_pool == NULL &&
801			(refcnt_pool = rte_pktmbuf_pool_create(
802				MAKE_STRING(refcnt_pool),
803				REFCNT_MBUF_NUM, 0, 0, 0,
804				SOCKET_ID_ANY)) == NULL) {
805		printf("%s: cannot allocate " MAKE_STRING(refcnt_pool) "\n",
806		    __func__);
807		return -1;
808	}
809
810	if (refcnt_mbuf_ring == NULL &&
811			(refcnt_mbuf_ring = rte_ring_create("refcnt_mbuf_ring",
812			REFCNT_RING_SIZE, SOCKET_ID_ANY,
813			RING_F_SP_ENQ)) == NULL) {
814		printf("%s: cannot allocate " MAKE_STRING(refcnt_mbuf_ring)
815		    "\n", __func__);
816		return -1;
817	}
818
819	refcnt_stop_slaves = 0;
820	memset(refcnt_lcore, 0, sizeof (refcnt_lcore));
821
822	rte_eal_mp_remote_launch(test_refcnt_slave, NULL, SKIP_MASTER);
823
824	test_refcnt_master();
825
826	rte_eal_mp_wait_lcore();
827
828	/* check that we porcessed all references */
829	tref = 0;
830	master = rte_get_master_lcore();
831
832	RTE_LCORE_FOREACH_SLAVE(slave)
833		tref += refcnt_lcore[slave];
834
835	if (tref != refcnt_lcore[master])
836		rte_panic("refernced mbufs: %u, freed mbufs: %u\n",
837		          tref, refcnt_lcore[master]);
838
839	rte_mempool_dump(stdout, refcnt_pool);
840	rte_ring_dump(stdout, refcnt_mbuf_ring);
841
842#endif
843	return 0;
844}
845
846#include <unistd.h>
847#include <sys/wait.h>
848
849/* use fork() to test mbuf errors panic */
850static int
851verify_mbuf_check_panics(struct rte_mbuf *buf)
852{
853	int pid;
854	int status;
855
856	pid = fork();
857
858	if (pid == 0) {
859		rte_mbuf_sanity_check(buf, 1); /* should panic */
860		exit(0);  /* return normally if it doesn't panic */
861	} else if (pid < 0){
862		printf("Fork Failed\n");
863		return -1;
864	}
865	wait(&status);
866	if(status == 0)
867		return -1;
868
869	return 0;
870}
871
872static int
873test_failing_mbuf_sanity_check(void)
874{
875	struct rte_mbuf *buf;
876	struct rte_mbuf badbuf;
877
878	printf("Checking rte_mbuf_sanity_check for failure conditions\n");
879
880	/* get a good mbuf to use to make copies */
881	buf = rte_pktmbuf_alloc(pktmbuf_pool);
882	if (buf == NULL)
883		return -1;
884	printf("Checking good mbuf initially\n");
885	if (verify_mbuf_check_panics(buf) != -1)
886		return -1;
887
888	printf("Now checking for error conditions\n");
889
890	if (verify_mbuf_check_panics(NULL)) {
891		printf("Error with NULL mbuf test\n");
892		return -1;
893	}
894
895	badbuf = *buf;
896	badbuf.pool = NULL;
897	if (verify_mbuf_check_panics(&badbuf)) {
898		printf("Error with bad-pool mbuf test\n");
899		return -1;
900	}
901
902	badbuf = *buf;
903	badbuf.buf_physaddr = 0;
904	if (verify_mbuf_check_panics(&badbuf)) {
905		printf("Error with bad-physaddr mbuf test\n");
906		return -1;
907	}
908
909	badbuf = *buf;
910	badbuf.buf_addr = NULL;
911	if (verify_mbuf_check_panics(&badbuf)) {
912		printf("Error with bad-addr mbuf test\n");
913		return -1;
914	}
915
916	badbuf = *buf;
917	badbuf.refcnt = 0;
918	if (verify_mbuf_check_panics(&badbuf)) {
919		printf("Error with bad-refcnt(0) mbuf test\n");
920		return -1;
921	}
922
923	badbuf = *buf;
924	badbuf.refcnt = UINT16_MAX;
925	if (verify_mbuf_check_panics(&badbuf)) {
926		printf("Error with bad-refcnt(MAX) mbuf test\n");
927		return -1;
928	}
929
930	return 0;
931}
932
933
934static int
935test_mbuf(void)
936{
937	RTE_BUILD_BUG_ON(sizeof(struct rte_mbuf) != RTE_CACHE_LINE_MIN_SIZE * 2);
938
939	/* create pktmbuf pool if it does not exist */
940	if (pktmbuf_pool == NULL) {
941		pktmbuf_pool = rte_pktmbuf_pool_create("test_pktmbuf_pool",
942			NB_MBUF, 32, 0, MBUF_DATA_SIZE, SOCKET_ID_ANY);
943	}
944
945	if (pktmbuf_pool == NULL) {
946		printf("cannot allocate mbuf pool\n");
947		return -1;
948	}
949
950	/* create a specific pktmbuf pool with a priv_size != 0 and no data
951	 * room size */
952	if (pktmbuf_pool2 == NULL) {
953		pktmbuf_pool2 = rte_pktmbuf_pool_create("test_pktmbuf_pool2",
954			NB_MBUF, 32, MBUF2_PRIV_SIZE, 0, SOCKET_ID_ANY);
955	}
956
957	if (pktmbuf_pool2 == NULL) {
958		printf("cannot allocate mbuf pool\n");
959		return -1;
960	}
961
962	/* test multiple mbuf alloc */
963	if (test_pktmbuf_pool() < 0) {
964		printf("test_mbuf_pool() failed\n");
965		return -1;
966	}
967
968	/* do it another time to check that all mbufs were freed */
969	if (test_pktmbuf_pool() < 0) {
970		printf("test_mbuf_pool() failed (2)\n");
971		return -1;
972	}
973
974	/* test that the pointer to the data on a packet mbuf is set properly */
975	if (test_pktmbuf_pool_ptr() < 0) {
976		printf("test_pktmbuf_pool_ptr() failed\n");
977		return -1;
978	}
979
980	/* test data manipulation in mbuf */
981	if (test_one_pktmbuf() < 0) {
982		printf("test_one_mbuf() failed\n");
983		return -1;
984	}
985
986
987	/*
988	 * do it another time, to check that allocation reinitialize
989	 * the mbuf correctly
990	 */
991	if (test_one_pktmbuf() < 0) {
992		printf("test_one_mbuf() failed (2)\n");
993		return -1;
994	}
995
996	if (test_pktmbuf_with_non_ascii_data() < 0) {
997		printf("test_pktmbuf_with_non_ascii_data() failed\n");
998		return -1;
999	}
1000
1001	/* test free pktmbuf segment one by one */
1002	if (test_pktmbuf_free_segment() < 0) {
1003		printf("test_pktmbuf_free_segment() failed.\n");
1004		return -1;
1005	}
1006
1007	if (testclone_testupdate_testdetach()<0){
1008		printf("testclone_and_testupdate() failed \n");
1009		return -1;
1010	}
1011
1012	if (test_attach_from_different_pool() < 0) {
1013		printf("test_attach_from_different_pool() failed\n");
1014		return -1;
1015	}
1016
1017	if (test_refcnt_mbuf()<0){
1018		printf("test_refcnt_mbuf() failed \n");
1019		return -1;
1020	}
1021
1022	if (test_failing_mbuf_sanity_check() < 0) {
1023		printf("test_failing_mbuf_sanity_check() failed\n");
1024		return -1;
1025	}
1026	return 0;
1027}
1028
1029static struct test_command mbuf_cmd = {
1030	.command = "mbuf_autotest",
1031	.callback = test_mbuf,
1032};
1033REGISTER_TEST_COMMAND(mbuf_cmd);
1034