/* * Copyright (c) 2015 Cisco and/or its affiliates. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at: * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* Copyright (c) 2001, 2002, 2003, 2004 Eliot Dresselhaus Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /** @file * @brief Fixed length block allocator. Pools are built from clib vectors and bitmaps. Use pools when repeatedly allocating and freeing fixed-size data. Pools are fast, and avoid memory fragmentation. */ #ifndef included_pool_h #define included_pool_h #include #include #include typedef struct { /** Bitmap of indices of free objects. */ uword *free_bitmap; /** Vector of free indices. One element for each set bit in bitmap. */ u32 *free_indices; /* The following fields are set for fixed-size, preallocated pools */ /** Maximum size of the pool, in elements */ u32 max_elts; /** mmap segment info: base + length */ u8 *mmap_base; u64 mmap_size; } pool_header_t; /** Align pool header so that pointers are naturally aligned. */ #define pool_aligned_header_bytes \ vec_aligned_header_bytes (sizeof (pool_header_t), sizeof (void *)) /** Get pool header from user pool pointer */ always_inline pool_header_t * pool_header (void *v) { return vec_aligned_header (v, sizeof (pool_header_t), sizeof (void *)); } extern void _pool_init_fixed (void **, u32, u32); extern void fpool_free (void *); /** initialize a fixed-size, preallocated pool */ #define pool_init_fixed(pool,max_elts) \ { \ _pool_init_fixed((void **)&(pool),sizeof(pool[0]),max_elts); \ } /** Validate a pool */ always_inline void pool_validate (void *v) { pool_header_t *p = pool_header (v); uword i, n_free_bitmap; if (!v) return; n_free_bitmap = clib_bitmap_count_set_bits (p->free_bitmap); ASSERT (n_free_bitmap == vec_len (p->free_indices)); for (i = 0; i < vec_len (p->free_indices); i++) ASSERT (clib_bitmap_get (p->free_bitmap, p->free_indices[i]) == 1); } always_inline void pool_header_validate_index (void *v, uword index) { pool_header_t *p = 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_internal(P,E,A,Z) \ do { \ pool_header_t * _pool_var (p) = pool_header (P); \ uword _pool_var (l); \ \ STATIC_ASSERT(A==0 || ((A % sizeof(P[0]))==0) || ((sizeof(P[0]) % A) == 0), \ "Pool aligned alloc of incorrectly sized object"); \ _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_notrim (_pool_var (p)->free_bitmap, \ _pool_var (i)); \ _vec_len (_pool_var (p)->free_indices) = _pool_var (l) - 1; \ } \ else \ { 
#!/usr/bin/env python3
# Copyright (c) 2016 Comcast Cable Communications Management, LLC.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at:
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# Looks for preprocessor macros with struct initializers and siphons them
# off into another file for later parsing; ostensibly to generate
# documentation from struct initializer data.

import argparse
import logging
import os

import siphon

DEFAULT_LOGFILE = None
DEFAULT_LOGLEVEL = "info"
DEFAULT_OUTPUT = "build-root/docs/siphons"
DEFAULT_PREFIX = os.getcwd()

ap = argparse.ArgumentParser()
ap.add_argument("--log-file", default=DEFAULT_LOGFILE,
                help="Log file [%s]" % DEFAULT_LOGFILE)
ap.add_argument("--log-level", default=DEFAULT_LOGLEVEL,
                choices=["debug", "info", "warning", "error", "critical"],
                help="Logging level [%s]" % DEFAULT_LOGLEVEL)

ap.add_argument("--output", '-o', metavar="directory", default=DEFAULT_OUTPUT,
                help="Output directory for .siphon files [%s]" %
                     DEFAULT_OUTPUT)
ap.add_argument("--input-prefix", metavar="path", default=DEFAULT_PREFIX,
                help="Prefix to strip from input pathnames [%s]" %
                     DEFAULT_PREFIX)
ap.add_argument("input", nargs='+', metavar="input_file",
                help="Input C source files")
args = ap.parse_args()

logging.basicConfig(filename