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