LCOV - code coverage report
Current view: top level - lib/ring - rte_ring.c (source / functions) Hit Total Coverage
Test: Code coverage Lines: 128 152 84.2 %
Date: 2024-01-22 15:35:40 Functions: 12 13 92.3 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 57 82 69.5 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  *
       3                 :            :  * Copyright (c) 2010-2015 Intel Corporation
       4                 :            :  * Copyright (c) 2007,2008 Kip Macy kmacy@freebsd.org
       5                 :            :  * All rights reserved.
       6                 :            :  * Derived from FreeBSD's bufring.h
       7                 :            :  * Used as BSD-3 Licensed with permission from Kip Macy.
       8                 :            :  */
       9                 :            : 
      10                 :            : #include <stdio.h>
      11                 :            : #include <string.h>
      12                 :            : #include <stdint.h>
      13                 :            : #include <inttypes.h>
      14                 :            : #include <errno.h>
      15                 :            : #include <sys/queue.h>
      16                 :            : 
      17                 :            : #include <rte_common.h>
      18                 :            : #include <rte_log.h>
      19                 :            : #include <rte_memzone.h>
      20                 :            : #include <rte_malloc.h>
      21                 :            : #include <rte_eal_memconfig.h>
      22                 :            : #include <rte_errno.h>
      23                 :            : #include <rte_string_fns.h>
      24                 :            : #include <rte_tailq.h>
      25                 :            : 
      26                 :            : #include "rte_ring.h"
      27                 :            : #include "rte_ring_elem.h"
      28                 :            : 
      29         [ -  + ]:        235 : RTE_LOG_REGISTER_DEFAULT(ring_logtype, INFO);
      30                 :            : #define RTE_LOGTYPE_RING ring_logtype
      31                 :            : #define RING_LOG(level, ...) \
      32                 :            :         RTE_LOG_LINE(level, RING, "" __VA_ARGS__)
      33                 :            : 
      34                 :            : TAILQ_HEAD(rte_ring_list, rte_tailq_entry);
      35                 :            : 
      36                 :            : static struct rte_tailq_elem rte_ring_tailq = {
      37                 :            :         .name = RTE_TAILQ_RING_NAME,
      38                 :            : };
      39         [ -  + ]:        235 : EAL_REGISTER_TAILQ(rte_ring_tailq)
      40                 :            : 
      41                 :            : /* mask of all valid flag values to ring_create() */
      42                 :            : #define RING_F_MASK (RING_F_SP_ENQ | RING_F_SC_DEQ | RING_F_EXACT_SZ | \
      43                 :            :                      RING_F_MP_RTS_ENQ | RING_F_MC_RTS_DEQ |           \
      44                 :            :                      RING_F_MP_HTS_ENQ | RING_F_MC_HTS_DEQ)
      45                 :            : 
      46                 :            : /* true if x is a power of 2 */
      47                 :            : #define POWEROF2(x) ((((x)-1) & (x)) == 0)
      48                 :            : 
      49                 :            : /* by default set head/tail distance as 1/8 of ring capacity */
      50                 :            : #define HTD_MAX_DEF     8
      51                 :            : 
      52                 :            : /* return the size of memory occupied by a ring */
      53                 :            : ssize_t
      54                 :        940 : rte_ring_get_memsize_elem(unsigned int esize, unsigned int count)
      55                 :            : {
      56                 :            :         ssize_t sz;
      57                 :            : 
      58                 :            :         /* Check if element size is a multiple of 4B */
      59         [ +  + ]:        940 :         if (esize % 4 != 0) {
      60                 :          1 :                 RING_LOG(ERR, "element size is not a multiple of 4");
      61                 :            : 
      62                 :          1 :                 return -EINVAL;
      63                 :            :         }
      64                 :            : 
      65                 :            :         /* count must be a power of 2 */
      66   [ +  +  +  + ]:        939 :         if ((!POWEROF2(count)) || (count > RTE_RING_SZ_MASK )) {
      67                 :         18 :                 RING_LOG(ERR,
      68                 :            :                         "Requested number of elements is invalid, must be power of 2, and not exceed %u",
      69                 :            :                         RTE_RING_SZ_MASK);
      70                 :            : 
      71                 :         18 :                 return -EINVAL;
      72                 :            :         }
      73                 :            : 
      74                 :        921 :         sz = sizeof(struct rte_ring) + (ssize_t)count * esize;
      75                 :        921 :         sz = RTE_ALIGN(sz, RTE_CACHE_LINE_SIZE);
      76                 :        921 :         return sz;
      77                 :            : }
      78                 :            : 
      79                 :            : /* return the size of memory occupied by a ring */
      80                 :            : ssize_t
      81                 :          0 : rte_ring_get_memsize(unsigned int count)
      82                 :            : {
      83                 :          0 :         return rte_ring_get_memsize_elem(sizeof(void *), count);
      84                 :            : }
      85                 :            : 
      86                 :            : /*
      87                 :            :  * internal helper function to reset prod/cons head-tail values.
      88                 :            :  */
      89                 :            : static void
      90                 :            : reset_headtail(void *p)
      91                 :            : {
      92                 :            :         struct rte_ring_headtail *ht;
      93                 :            :         struct rte_ring_hts_headtail *ht_hts;
      94                 :            :         struct rte_ring_rts_headtail *ht_rts;
      95                 :            : 
      96                 :            :         ht = p;
      97                 :            :         ht_hts = p;
      98                 :            :         ht_rts = p;
      99                 :            : 
     100                 :         40 :         switch (ht->sync_type) {
     101                 :         40 :         case RTE_RING_SYNC_MT:
     102                 :            :         case RTE_RING_SYNC_ST:
     103                 :         40 :                 ht->head = 0;
     104                 :         40 :                 ht->tail = 0;
     105                 :         40 :                 break;
     106                 :          0 :         case RTE_RING_SYNC_MT_RTS:
     107                 :          0 :                 ht_rts->head.raw = 0;
     108                 :          0 :                 ht_rts->tail.raw = 0;
     109                 :          0 :                 break;
     110                 :          0 :         case RTE_RING_SYNC_MT_HTS:
     111                 :          0 :                 ht_hts->ht.raw = 0;
     112                 :          0 :                 break;
     113   [ +  -  -  - ]:         20 :         default:
     114                 :            :                 /* unknown sync mode */
     115                 :            :                 RTE_ASSERT(0);
     116                 :            :         }
     117                 :            : }
     118                 :            : 
     119                 :            : void
     120   [ +  -  -  - ]:         20 : rte_ring_reset(struct rte_ring *r)
     121                 :            : {
     122                 :            :         reset_headtail(&r->prod);
     123                 :            :         reset_headtail(&r->cons);
     124                 :         20 : }
     125                 :            : 
     126                 :            : /*
     127                 :            :  * helper function, calculates sync_type values for prod and cons
     128                 :            :  * based on input flags. Returns zero at success or negative
     129                 :            :  * errno value otherwise.
     130                 :            :  */
     131                 :            : static int
     132                 :        899 : get_sync_type(uint32_t flags, enum rte_ring_sync_type *prod_st,
     133                 :            :         enum rte_ring_sync_type *cons_st)
     134                 :            : {
     135                 :            :         static const uint32_t prod_st_flags =
     136                 :            :                 (RING_F_SP_ENQ | RING_F_MP_RTS_ENQ | RING_F_MP_HTS_ENQ);
     137                 :            :         static const uint32_t cons_st_flags =
     138                 :            :                 (RING_F_SC_DEQ | RING_F_MC_RTS_DEQ | RING_F_MC_HTS_DEQ);
     139                 :            : 
     140   [ +  +  +  +  :        899 :         switch (flags & prod_st_flags) {
                      - ]
     141                 :        339 :         case 0:
     142                 :        339 :                 *prod_st = RTE_RING_SYNC_MT;
     143                 :        339 :                 break;
     144                 :        430 :         case RING_F_SP_ENQ:
     145                 :        430 :                 *prod_st = RTE_RING_SYNC_ST;
     146                 :        430 :                 break;
     147                 :         50 :         case RING_F_MP_RTS_ENQ:
     148                 :         50 :                 *prod_st = RTE_RING_SYNC_MT_RTS;
     149                 :         50 :                 break;
     150                 :         80 :         case RING_F_MP_HTS_ENQ:
     151                 :         80 :                 *prod_st = RTE_RING_SYNC_MT_HTS;
     152                 :         80 :                 break;
     153                 :            :         default:
     154                 :            :                 return -EINVAL;
     155                 :            :         }
     156                 :            : 
     157   [ +  +  +  +  :        899 :         switch (flags & cons_st_flags) {
                      - ]
     158                 :        340 :         case 0:
     159                 :        340 :                 *cons_st = RTE_RING_SYNC_MT;
     160                 :        340 :                 break;
     161                 :        426 :         case RING_F_SC_DEQ:
     162                 :        426 :                 *cons_st = RTE_RING_SYNC_ST;
     163                 :        426 :                 break;
     164                 :         40 :         case RING_F_MC_RTS_DEQ:
     165                 :         40 :                 *cons_st = RTE_RING_SYNC_MT_RTS;
     166                 :         40 :                 break;
     167                 :         93 :         case RING_F_MC_HTS_DEQ:
     168                 :         93 :                 *cons_st = RTE_RING_SYNC_MT_HTS;
     169                 :         93 :                 break;
     170                 :            :         default:
     171                 :            :                 return -EINVAL;
     172                 :            :         }
     173                 :            : 
     174                 :            :         return 0;
     175                 :            : }
     176                 :            : 
     177                 :            : int
     178                 :        899 : rte_ring_init(struct rte_ring *r, const char *name, unsigned int count,
     179                 :            :         unsigned int flags)
     180                 :            : {
     181                 :            :         int ret;
     182                 :            : 
     183                 :            :         /* compilation-time checks */
     184                 :            :         RTE_BUILD_BUG_ON((sizeof(struct rte_ring) &
     185                 :            :                           RTE_CACHE_LINE_MASK) != 0);
     186                 :            :         RTE_BUILD_BUG_ON((offsetof(struct rte_ring, cons) &
     187                 :            :                           RTE_CACHE_LINE_MASK) != 0);
     188                 :            :         RTE_BUILD_BUG_ON((offsetof(struct rte_ring, prod) &
     189                 :            :                           RTE_CACHE_LINE_MASK) != 0);
     190                 :            : 
     191                 :            :         RTE_BUILD_BUG_ON(offsetof(struct rte_ring_headtail, sync_type) !=
     192                 :            :                 offsetof(struct rte_ring_hts_headtail, sync_type));
     193                 :            :         RTE_BUILD_BUG_ON(offsetof(struct rte_ring_headtail, tail) !=
     194                 :            :                 offsetof(struct rte_ring_hts_headtail, ht.pos.tail));
     195                 :            : 
     196                 :            :         RTE_BUILD_BUG_ON(offsetof(struct rte_ring_headtail, sync_type) !=
     197                 :            :                 offsetof(struct rte_ring_rts_headtail, sync_type));
     198                 :            :         RTE_BUILD_BUG_ON(offsetof(struct rte_ring_headtail, tail) !=
     199                 :            :                 offsetof(struct rte_ring_rts_headtail, tail.val.pos));
     200                 :            : 
     201                 :            :         /* future proof flags, only allow supported values */
     202         [ -  + ]:        899 :         if (flags & ~RING_F_MASK) {
     203                 :          0 :                 RING_LOG(ERR,
     204                 :            :                         "Unsupported flags requested %#x", flags);
     205                 :          0 :                 return -EINVAL;
     206                 :            :         }
     207                 :            : 
     208                 :            :         /* init the ring structure */
     209                 :            :         memset(r, 0, sizeof(*r));
     210         [ +  - ]:        899 :         ret = strlcpy(r->name, name, sizeof(r->name));
     211         [ +  - ]:        899 :         if (ret < 0 || ret >= (int)sizeof(r->name))
     212                 :            :                 return -ENAMETOOLONG;
     213                 :        899 :         r->flags = flags;
     214                 :        899 :         ret = get_sync_type(flags, &r->prod.sync_type, &r->cons.sync_type);
     215         [ +  - ]:        899 :         if (ret != 0)
     216                 :            :                 return ret;
     217                 :            : 
     218         [ +  + ]:        899 :         if (flags & RING_F_EXACT_SZ) {
     219                 :        238 :                 r->size = rte_align32pow2(count + 1);
     220                 :        238 :                 r->mask = r->size - 1;
     221                 :        238 :                 r->capacity = count;
     222                 :            :         } else {
     223   [ +  -  -  + ]:        661 :                 if ((!POWEROF2(count)) || (count > RTE_RING_SZ_MASK)) {
     224                 :          0 :                         RING_LOG(ERR,
     225                 :            :                                 "Requested size is invalid, must be power of 2, and not exceed the size limit %u",
     226                 :            :                                 RTE_RING_SZ_MASK);
     227                 :          0 :                         return -EINVAL;
     228                 :            :                 }
     229                 :        661 :                 r->size = count;
     230                 :        661 :                 r->mask = count - 1;
     231                 :        661 :                 r->capacity = r->mask;
     232                 :            :         }
     233                 :            : 
     234                 :            :         /* set default values for head-tail distance */
     235         [ +  + ]:        899 :         if (flags & RING_F_MP_RTS_ENQ)
     236         [ +  - ]:         50 :                 rte_ring_set_prod_htd_max(r, r->capacity / HTD_MAX_DEF);
     237         [ +  + ]:        899 :         if (flags & RING_F_MC_RTS_DEQ)
     238         [ +  - ]:         40 :                 rte_ring_set_cons_htd_max(r, r->capacity / HTD_MAX_DEF);
     239                 :            : 
     240                 :            :         return 0;
     241                 :            : }
     242                 :            : 
     243                 :            : /* create the ring for a given element size */
     244                 :            : struct rte_ring *
     245                 :        940 : rte_ring_create_elem(const char *name, unsigned int esize, unsigned int count,
     246                 :            :                 int socket_id, unsigned int flags)
     247                 :            : {
     248                 :            :         char mz_name[RTE_MEMZONE_NAMESIZE];
     249                 :            :         struct rte_ring *r;
     250                 :            :         struct rte_tailq_entry *te;
     251                 :            :         const struct rte_memzone *mz;
     252                 :            :         ssize_t ring_size;
     253                 :            :         int mz_flags = 0;
     254                 :            :         struct rte_ring_list* ring_list = NULL;
     255                 :            :         const unsigned int requested_count = count;
     256                 :            :         int ret;
     257                 :            : 
     258                 :        940 :         ring_list = RTE_TAILQ_CAST(rte_ring_tailq.head, rte_ring_list);
     259                 :            : 
     260                 :            :         /* for an exact size ring, round up from count to a power of two */
     261         [ +  + ]:        940 :         if (flags & RING_F_EXACT_SZ)
     262                 :            :                 count = rte_align32pow2(count + 1);
     263                 :            : 
     264                 :        940 :         ring_size = rte_ring_get_memsize_elem(esize, count);
     265         [ +  + ]:        941 :         if (ring_size < 0) {
     266                 :         19 :                 rte_errno = -ring_size;
     267                 :         19 :                 return NULL;
     268                 :            :         }
     269                 :            : 
     270                 :            :         ret = snprintf(mz_name, sizeof(mz_name), "%s%s",
     271                 :            :                 RTE_RING_MZ_PREFIX, name);
     272         [ -  + ]:        922 :         if (ret < 0 || ret >= (int)sizeof(mz_name)) {
     273                 :          0 :                 rte_errno = ENAMETOOLONG;
     274                 :          0 :                 return NULL;
     275                 :            :         }
     276                 :            : 
     277                 :        922 :         te = rte_zmalloc("RING_TAILQ_ENTRY", sizeof(*te), 0);
     278         [ -  + ]:        922 :         if (te == NULL) {
     279                 :          0 :                 RING_LOG(ERR, "Cannot reserve memory for tailq");
     280                 :          0 :                 rte_errno = ENOMEM;
     281                 :          0 :                 return NULL;
     282                 :            :         }
     283                 :            : 
     284                 :        922 :         rte_mcfg_tailq_write_lock();
     285                 :            : 
     286                 :            :         /* reserve a memory zone for this ring. If we can't get rte_config or
     287                 :            :          * we are secondary process, the memzone_reserve function will set
     288                 :            :          * rte_errno for us appropriately - hence no check in this function
     289                 :            :          */
     290                 :        922 :         mz = rte_memzone_reserve_aligned(mz_name, ring_size, socket_id,
     291                 :            :                                          mz_flags, __alignof__(*r));
     292         [ +  + ]:        922 :         if (mz != NULL) {
     293                 :        899 :                 r = mz->addr;
     294                 :            :                 /* no need to check return value here, we already checked the
     295                 :            :                  * arguments above */
     296                 :        899 :                 rte_ring_init(r, name, requested_count, flags);
     297                 :            : 
     298                 :        899 :                 te->data = (void *) r;
     299                 :        899 :                 r->memzone = mz;
     300                 :            : 
     301                 :        899 :                 TAILQ_INSERT_TAIL(ring_list, te, next);
     302                 :            :         } else {
     303                 :            :                 r = NULL;
     304                 :         23 :                 RING_LOG(ERR, "Cannot reserve memory");
     305                 :         23 :                 rte_free(te);
     306                 :            :         }
     307                 :        922 :         rte_mcfg_tailq_write_unlock();
     308                 :            : 
     309                 :        922 :         return r;
     310                 :            : }
     311                 :            : 
     312                 :            : /* create the ring */
     313                 :            : struct rte_ring *
     314                 :        294 : rte_ring_create(const char *name, unsigned int count, int socket_id,
     315                 :            :                 unsigned int flags)
     316                 :            : {
     317                 :        294 :         return rte_ring_create_elem(name, sizeof(void *), count, socket_id,
     318                 :            :                 flags);
     319                 :            : }
     320                 :            : 
     321                 :            : /* free the ring */
     322                 :            : void
     323                 :       1201 : rte_ring_free(struct rte_ring *r)
     324                 :            : {
     325                 :            :         struct rte_ring_list *ring_list = NULL;
     326                 :            :         struct rte_tailq_entry *te;
     327                 :            : 
     328         [ +  + ]:       1201 :         if (r == NULL)
     329                 :            :                 return;
     330                 :            : 
     331                 :            :         /*
     332                 :            :          * Ring was not created with rte_ring_create,
     333                 :            :          * therefore, there is no memzone to free.
     334                 :            :          */
     335         [ -  + ]:        875 :         if (r->memzone == NULL) {
     336                 :          0 :                 RING_LOG(ERR,
     337                 :            :                         "Cannot free ring, not created with rte_ring_create()");
     338                 :          0 :                 return;
     339                 :            :         }
     340                 :            : 
     341                 :        875 :         ring_list = RTE_TAILQ_CAST(rte_ring_tailq.head, rte_ring_list);
     342                 :        875 :         rte_mcfg_tailq_write_lock();
     343                 :            : 
     344                 :            :         /* find out tailq entry */
     345         [ +  - ]:       2371 :         TAILQ_FOREACH(te, ring_list, next) {
     346         [ +  + ]:       2371 :                 if (te->data == (void *) r)
     347                 :            :                         break;
     348                 :            :         }
     349                 :            : 
     350         [ -  + ]:        875 :         if (te == NULL) {
     351                 :          0 :                 rte_mcfg_tailq_write_unlock();
     352                 :          0 :                 return;
     353                 :            :         }
     354                 :            : 
     355         [ +  + ]:        875 :         TAILQ_REMOVE(ring_list, te, next);
     356                 :            : 
     357                 :        875 :         rte_mcfg_tailq_write_unlock();
     358                 :            : 
     359         [ -  + ]:        875 :         if (rte_memzone_free(r->memzone) != 0)
     360                 :          0 :                 RING_LOG(ERR, "Cannot free memory");
     361                 :            : 
     362                 :        875 :         rte_free(te);
     363                 :            : }
     364                 :            : 
     365                 :            : /* dump the status of the ring on the console */
     366                 :            : void
     367                 :          1 : rte_ring_dump(FILE *f, const struct rte_ring *r)
     368                 :            : {
     369                 :          1 :         fprintf(f, "ring <%s>@%p\n", r->name, r);
     370                 :          1 :         fprintf(f, "  flags=%x\n", r->flags);
     371                 :          1 :         fprintf(f, "  size=%"PRIu32"\n", r->size);
     372                 :          1 :         fprintf(f, "  capacity=%"PRIu32"\n", r->capacity);
     373                 :          1 :         fprintf(f, "  ct=%"PRIu32"\n", r->cons.tail);
     374                 :          1 :         fprintf(f, "  ch=%"PRIu32"\n", r->cons.head);
     375                 :          1 :         fprintf(f, "  pt=%"PRIu32"\n", r->prod.tail);
     376                 :          1 :         fprintf(f, "  ph=%"PRIu32"\n", r->prod.head);
     377                 :            :         fprintf(f, "  used=%u\n", rte_ring_count(r));
     378                 :            :         fprintf(f, "  avail=%u\n", rte_ring_free_count(r));
     379                 :          1 : }
     380                 :            : 
     381                 :            : /* dump the status of all rings on the console */
     382                 :            : void
     383                 :          1 : rte_ring_list_dump(FILE *f)
     384                 :            : {
     385                 :            :         const struct rte_tailq_entry *te;
     386                 :            :         struct rte_ring_list *ring_list;
     387                 :            : 
     388                 :          1 :         ring_list = RTE_TAILQ_CAST(rte_ring_tailq.head, rte_ring_list);
     389                 :            : 
     390                 :          1 :         rte_mcfg_tailq_read_lock();
     391                 :            : 
     392         [ -  + ]:          1 :         TAILQ_FOREACH(te, ring_list, next) {
     393                 :          0 :                 rte_ring_dump(f, (struct rte_ring *) te->data);
     394                 :            :         }
     395                 :            : 
     396                 :          1 :         rte_mcfg_tailq_read_unlock();
     397                 :          1 : }
     398                 :            : 
     399                 :            : /* search a ring from its name */
     400                 :            : struct rte_ring *
     401                 :        349 : rte_ring_lookup(const char *name)
     402                 :            : {
     403                 :            :         struct rte_tailq_entry *te;
     404                 :            :         struct rte_ring *r = NULL;
     405                 :            :         struct rte_ring_list *ring_list;
     406                 :            : 
     407                 :        349 :         ring_list = RTE_TAILQ_CAST(rte_ring_tailq.head, rte_ring_list);
     408                 :            : 
     409                 :        349 :         rte_mcfg_tailq_read_lock();
     410                 :            : 
     411         [ +  + ]:       3023 :         TAILQ_FOREACH(te, ring_list, next) {
     412                 :       2860 :                 r = (struct rte_ring *) te->data;
     413         [ +  + ]:       2860 :                 if (strncmp(name, r->name, RTE_RING_NAMESIZE) == 0)
     414                 :            :                         break;
     415                 :            :         }
     416                 :            : 
     417                 :        344 :         rte_mcfg_tailq_read_unlock();
     418                 :            : 
     419         [ +  + ]:        346 :         if (te == NULL) {
     420                 :        167 :                 rte_errno = ENOENT;
     421                 :        167 :                 return NULL;
     422                 :            :         }
     423                 :            : 
     424                 :            :         return r;
     425                 :            : }

Generated by: LCOV version 1.14