aboutsummaryrefslogtreecommitdiffstats
path: root/src
AgeCommit message (Expand)AuthorFilesLines
2021-07-15misc: replace CLIB_PREFETCH with clib_prefetch_{load,store}Damjan Marion70-288/+282
2021-07-15nat: nat44-ed sm fixFilip Varga1-15/+13
2021-07-14vppinfra: remove old and unused vector macros and inlinesDamjan Marion3-257/+0
2021-07-14api: fix memory error in multi-thread environmentXiaoming Jiang1-1/+7
2021-07-14vcl:fix segfault when unshare NO_MQ sessionliuyacan1-1/+2
2021-07-14nat: refactoring NAT44ED cfg functionsFilip Varga4-344/+500
2021-07-14ip: fix check_adj_port_range_x1Damjan Marion1-2/+2
2021-07-14classify: cheaper way to check if all elements are zeroDamjan Marion1-1/+1
2021-07-14ip: improve check_adj_port_range_x1Damjan Marion1-35/+5
2021-07-13vppinfra: fix saturate add/sub NEON wrappersLijian.Zhang1-40/+60
2021-07-13vppinfra: put each vector function into own fileDamjan Marion9-81/+94
2021-07-13misc: remove vnet_all_api_h and vnet_msg_enumFilip Tehlar11-135/+3
2021-07-13fib: Set the GLEAN flag on attached export routes so that the SAS worksNeale Ranns4-38/+63
2021-07-13tcp session: next node config on connectsFlorin Coras2-3/+9
2021-07-13mss_clamp: coverity test fixMiklos Tirpak1-3/+6
2021-07-13misc: fix init order to avoid startup warningsBin Zhou (bzhou2)4-27/+14
2021-07-13dpdk: add base-virtaddr config optionRobert Shearman1-1/+4
2021-07-13vppinfra: fix SIGSEGV in clib_mem_vm_unmapchenqijun1-4/+6
2021-07-12papi: remove shared memory transportOle Troan6-157/+6
2021-07-12session: api cleanupFilip Tehlar9-441/+117
2021-07-08session: allow listen in any fib if default namespaceFlorin Coras3-3/+12
2021-07-08interface: unable to to assign tx queue to last worker threadSteven Luong1-4/+3
2021-07-08tap: Set the MTU on the TUN deivceNeale Ranns1-0/+13
2021-07-06tcp: use tcp output for half open connectionsFlorin Coras1-39/+12
2021-07-06tcp: use main thread pool for half-opensFlorin Coras5-146/+29
2021-07-06l3xc: reset dpo on deleteBenoît Ganne1-0/+1
2021-07-06vcl: fix packetdrill test errorwanghanlin1-1/+1
2021-07-06vcl: print current app state for timeoutwanghanlin1-2/+2
2021-07-06vcl: fix return value check for ldp_fd_to_vlshwanghanlin1-3/+3
2021-07-02ipsec: ADD/update IPSec documentationNeale Ranns1-0/+199
2021-07-02interface: api cleanupFilip Tehlar4-1439/+36
2021-07-02sr: do not use vnet_all_api.hFilip Tehlar2-34/+33
2021-07-02vlib: fix buffer pool alignment sizeTianyu Li1-1/+1
2021-07-02crypto: fix sw async crypto with chained buffersBenoît Ganne1-31/+30
2021-07-02misc: Don't IPv[46] enable local0, it doesn't receive packets.Neale Ranns1-5/+0
2021-07-01vmxnet3: support manual thread assignment to tx queueSteven Luong3-18/+26
2021-07-01ip: api cleanupFilip Tehlar5-1693/+88
2021-06-30memif: fix tx desc length for chained buffers in copy modeBenoît Ganne1-0/+1
2021-06-30rdma: fix chained buffer tx path in dv modeBenoît Ganne1-24/+20
2021-06-30memif: fix chain buffer length in zero-copy modeBenoît Ganne1-0/+1
2021-06-30vcl: coverity fixesFlorin Coras1-1/+1
2021-06-30ipsec: Derive the TUNNEL_V6 flag from the configured address typesNeale Ranns2-1/+8
2021-06-29session: free ctrl event data on connect rpcFlorin Coras1-0/+1
2021-06-29ipsec: Fix setting the hi-sequence number for decryptNeale Ranns7-135/+229
2021-06-29tcp: add ACK flag to RST packetliuyacan1-1/+1
2021-06-29vcl: improvements to epoll ltFlorin Coras3-52/+85
2021-06-29ipsec: increment SPD policy counters for bypass and discard actions in ipsec4...Zachary Leaf1-0/+20
2021-06-29vcl: Don't use app_socket_api to notify VPP in parent when child exitedwanghanlin1-1/+5
2021-06-29vcl: Don't memset events to optimize CPU usagewanghanlin1-8/+6
2021-06-28vcl: epoll fix postponed evt handlingFlorin Coras1-6/+33
n class="n">pool_header (v); if (v) vec_validate (p->free_bitmap, index / BITS (uword)); } #define pool_validate_index(v,i) \ do { \ uword __pool_validate_index = (i); \ vec_validate_ha ((v), __pool_validate_index, \ pool_aligned_header_bytes, /* align */ 0); \ pool_header_validate_index ((v), __pool_validate_index); \ } while (0) /** Number of active elements in a pool. * @return Number of active elements in a pool */ always_inline uword pool_elts (void *v) { uword ret = vec_len (v); if (v) ret -= vec_len (pool_header (v)->free_indices); return ret; } /** Number of elements in pool vector. @note You probably want to call pool_elts() instead. */ #define pool_len(p) vec_len(p) /** Number of elements in pool vector (usable as an lvalue) @note You probably don't want to use this macro. */ #define _pool_len(p) _vec_len(p) /** Memory usage of pool header. */ always_inline uword pool_header_bytes (void *v) { pool_header_t *p = pool_header (v); if (!v) return 0; return vec_bytes (p->free_bitmap) + vec_bytes (p->free_indices); } /** Memory usage of pool. */ #define pool_bytes(P) (vec_bytes (P) + pool_header_bytes (P)) /** Local variable naming macro. */ #define _pool_var(v) _pool_##v /** Queries whether pool has at least N_FREE free elements. */ always_inline uword pool_free_elts (void *v) { pool_header_t *p = pool_header (v); uword n_free = 0; if (v) { n_free += vec_len (p->free_indices); /* Space left at end of vector? */ n_free += vec_capacity (v, sizeof (p[0])) - vec_len (v); } return n_free; } /** Allocate an object E from a pool P (general version). First search free list. If nothing is free extend vector of objects. */ #define pool_get_aligned(P,E,A) \ do { \ pool_header_t * _pool_var (p) = pool_header (P); \ uword _pool_var (l); \ \ _pool_var (l) = 0; \ if (P) \ _pool_var (l) = vec_len (_pool_var (p)->free_indices); \ \ if (_pool_var (l) > 0) \ { \ /* Return free element from free list. */ \ uword _pool_var (i) = _pool_var (p)->free_indices[_pool_var (l) - 1]; \ (E) = (P) + _pool_var (i); \ _pool_var (p)->free_bitmap = \ clib_bitmap_andnoti (_pool_var (p)->free_bitmap, _pool_var (i)); \ _vec_len (_pool_var (p)->free_indices) = _pool_var (l) - 1; \ } \ else \ { \ /* fixed-size, preallocated pools cannot expand */ \ if ((P) && _pool_var(p)->max_elts) \ { \ clib_warning ("can't expand fixed-size pool"); \ os_out_of_memory(); \ } \ /* Nothing on free list, make a new element and return it. */ \ P = _vec_resize (P, \ /* length_increment */ 1, \ /* new size */ (vec_len (P) + 1) * sizeof (P[0]), \ pool_aligned_header_bytes, \ /* align */ (A)); \ E = vec_end (P) - 1; \ } \ } while (0) /** Allocate an object E from a pool P (unspecified alignment). */ #define pool_get(P,E) pool_get_aligned(P,E,0) /** See if pool_get will expand the pool or not */ #define pool_get_aligned_will_expand(P,YESNO,A) \ do { \ pool_header_t * _pool_var (p) = pool_header (P); \ uword _pool_var (l); \ \ _pool_var (l) = 0; \ if (P) \ { \ if (_pool_var (p)->max_elts) \ _pool_var (l) = _pool_var (p)->max_elts; \ else \ _pool_var (l) = vec_len (_pool_var (p)->free_indices); \ } \ \ /* Free elements, certainly won't expand */ \ if (_pool_var (l) > 0) \ YESNO=0; \ else \ { \ /* Nothing on free list, make a new element and return it. */ \ YESNO = _vec_resize_will_expand \ (P, \ /* length_increment */ 1, \ /* new size */ (vec_len (P) + 1) * sizeof (P[0]), \ pool_aligned_header_bytes, \ /* align */ (A)); \ } \ } while (0) #define pool_get_will_expand(P,YESNO) pool_get_aligned_will_expand(P,YESNO,0) /** Use free bitmap to query whether given element is free. */ #define pool_is_free(P,E) \ ({ \ pool_header_t * _pool_var (p) = pool_header (P); \ uword _pool_var (i) = (E) - (P); \ (_pool_var (i) < vec_len (P)) ? clib_bitmap_get (_pool_var (p)->free_bitmap, _pool_i) : 1; \ }) /** Use free bitmap to query whether given index is free */ #define pool_is_free_index(P,I) pool_is_free((P),(P)+(I)) /** Free an object E in pool P. */ #define pool_put(P,E) \ do { \ pool_header_t * _pool_var (p) = pool_header (P); \ uword _pool_var (l) = (E) - (P); \ ASSERT (vec_is_member (P, E)); \ ASSERT (! pool_is_free (P, E)); \ \ /* Add element to free bitmap and to free list. */ \ _pool_var (p)->free_bitmap = \ clib_bitmap_ori (_pool_var (p)->free_bitmap, _pool_var (l)); \ /* Preallocated pool? */ \ if (_pool_var (p)->max_elts) \ { \ ASSERT(_pool_var(l) < _pool_var (p)->max_elts); \ _pool_var(p)->free_indices[_vec_len(_pool_var(p)->free_indices)] = \ _pool_var(l); \ _vec_len(_pool_var(p)->free_indices) += 1; \ } \ else \ vec_add1 (_pool_var (p)->free_indices, _pool_var (l)); \ } while (0) /** Free pool element with given index. */ #define pool_put_index(p,i) \ do { \ typeof (p) _e = (p) + (i); \ pool_put (p, _e); \ } while (0) /** Allocate N more free elements to pool (general version). */ #define pool_alloc_aligned(P,N,A) \ do { \ pool_header_t * _p; \ \ if ((P)) \ { \ _p = pool_header (P); \ if (_p->max_elts) \ { \ clib_warning ("Can't expand fixed-size pool"); \ os_out_of_memory(); \ } \ } \ \ (P) = _vec_resize ((P), 0, (vec_len (P) + (N)) * sizeof (P[0]), \ pool_aligned_header_bytes, \ (A)); \ _p = pool_header (P); \ vec_resize (_p->free_indices, (N)); \ _vec_len (_p->free_indices) -= (N); \ } while (0) /** Allocate N more free elements to pool (unspecified alignment). */ #define pool_alloc(P,N) pool_alloc_aligned(P,N,0) /** Low-level free pool operator (do not call directly). */ always_inline void * _pool_free (void *v) { pool_header_t *p = pool_header (v); if (!v) return v; clib_bitmap_free (p->free_bitmap); if (p->max_elts) { int rv; rv = munmap (p->mmap_base, p->mmap_size); if (rv) clib_unix_warning ("munmap"); } else { vec_free (p->free_indices); vec_free_h (v, pool_aligned_header_bytes); } return 0; } /** Free a pool. */ #define pool_free(p) (p) = _pool_free(p) /** Optimized iteration through pool. @param LO pointer to first element in chunk @param HI pointer to last element in chunk @param POOL pool to iterate across @param BODY operation to perform Optimized version which assumes that BODY is smart enough to process multiple (LOW,HI) chunks. See also pool_foreach(). */ #define pool_foreach_region(LO,HI,POOL,BODY) \ do { \ uword _pool_var (i), _pool_var (lo), _pool_var (hi), _pool_var (len); \ uword _pool_var (bl), * _pool_var (b); \ pool_header_t * _pool_var (p); \ \ _pool_var (p) = pool_header (POOL); \ _pool_var (b) = (POOL) ? _pool_var (p)->free_bitmap : 0; \ _pool_var (bl) = vec_len (_pool_var (b)); \ _pool_var (len) = vec_len (POOL); \ _pool_var (lo) = 0; \ \ for (_pool_var (i) = 0; \ _pool_var (i) <= _pool_var (bl); \ _pool_var (i)++) \ { \ uword _pool_var (m), _pool_var (f); \ _pool_var (m) = (_pool_var (i) < _pool_var (bl) \ ? _pool_var (b) [_pool_var (i)] \ : 1); \ while (_pool_var (m) != 0) \ { \ _pool_var (f) = first_set (_pool_var (m)); \ _pool_var (hi) = (_pool_var (i) * BITS (_pool_var (b)[0]) \ + min_log2 (_pool_var (f))); \ _pool_var (hi) = (_pool_var (i) < _pool_var (bl) \ ? _pool_var (hi) : _pool_var (len)); \ _pool_var (m) ^= _pool_var (f); \ if (_pool_var (hi) > _pool_var (lo)) \ { \ (LO) = _pool_var (lo); \ (HI) = _pool_var (hi); \ do { BODY; } while (0); \ } \ _pool_var (lo) = _pool_var (hi) + 1; \ } \ } \ } while (0) /** Iterate through pool. @param VAR A variable of same type as pool vector to be used as an iterator. @param POOL The pool to iterate across. @param BODY The operation to perform, typically a code block. See the example below. This macro will call @c BODY with each active pool element. It is a bad idea to allocate or free pool element from within @c pool_foreach. Build a vector of indices and dispose of them later. Or call pool_flush. @par Example @code{.c} proc_t *procs; // a pool of processes. proc_t *proc; // pointer to one process; used as the iterator. pool_foreach (proc, procs, ({ if (proc->state != PROC_STATE_RUNNING) continue; // check a running proc in some way ... })); @endcode @warning Because @c pool_foreach is a macro, syntax errors can be difficult to find inside @c BODY, let alone actual code bugs. One can temporarily split a complex @c pool_foreach into a trivial @c pool_foreach which builds a vector of active indices, and a vec_foreach() (or plain for-loop) to walk the active index vector. */ #define pool_foreach(VAR,POOL,BODY) \ do { \ uword _pool_foreach_lo, _pool_foreach_hi; \ pool_foreach_region (_pool_foreach_lo, _pool_foreach_hi, (POOL), \ ({ \ for ((VAR) = (POOL) + _pool_foreach_lo; \ (VAR) < (POOL) + _pool_foreach_hi; \ (VAR)++) \ do { BODY; } while (0); \ })); \ } while (0) /** Returns pointer to element at given index. ASSERTs that the supplied index is valid. Even though one can write correct code of the form @code p = pool_base + index; @endcode use of @c pool_elt_at_index is strongly suggested. */ #define pool_elt_at_index(p,i) \ ({ \ typeof (p) _e = (p) + (i); \ ASSERT (! pool_is_free (p, _e)); \ _e; \ }) /** Return next occupied pool index after @c i, useful for safe iteration. */ #define pool_next_index(P,I) \ ({ \ pool_header_t * _pool_var (p) = pool_header (P); \ uword _pool_var (rv) = (I) + 1; \ \ _pool_var(rv) = \ (_pool_var (rv) < vec_len (P) ? \ clib_bitmap_next_clear (_pool_var (p)->free_bitmap, _pool_var(rv)) \ : ~0); \ _pool_var(rv); \ }) /** Iterate pool by index. */ #define pool_foreach_index(i,v,body) \ for ((i) = 0; (i) < vec_len (v); (i)++) \ { \ if (! pool_is_free_index ((v), (i))) \ do { body; } while (0); \ } /** * @brief Remove all elemenets from a pool in a safe way * * @param VAR each element in the pool * @param POOL The pool to flush * @param BODY The actions to perform on each element before it is returned to * the pool. i.e. before it is 'freed' */ #define pool_flush(VAR, POOL, BODY) \ { \ uword *_pool_var(ii), *_pool_var(dv) = NULL; \ \ pool_foreach((VAR), (POOL), \ ({ \ vec_add1(_pool_var(dv), (VAR) - (POOL)); \ })); \ vec_foreach(_pool_var(ii), _pool_var(dv)) \ { \ (VAR) = pool_elt_at_index((POOL), *_pool_var(ii)); \ do { BODY; } while (0); \ pool_put((POOL), (VAR)); \ } \ vec_free(_pool_var(dv)); \ } #endif /* included_pool_h */ /* * fd.io coding-style-patch-verification: ON * * Local Variables: * eval: (c-set-style "gnu") * End: */