diff options
author | Harald Welte <laforge@gnumonks.org> | 2017-05-07 13:18:36 +0200 |
---|---|---|
committer | Harald Welte <laforge@gnumonks.org> | 2017-05-07 13:18:36 +0200 |
commit | eb81d23a56d0ce66611f348858ecd4814650521e (patch) | |
tree | 4b595b30f6e6b0be4d429b0b9b04af274c4e942f /firmware/libosmocore | |
parent | 0380d74405e10502c7244e9e2592d934ac55b8ed (diff) |
import libosmocore msgb handling (and dependencies)
This is supposed to be replaced with upstream libosmocore, as soon as
that has a proper maintained embedded build (again).
Diffstat (limited to 'firmware/libosmocore')
-rw-r--r-- | firmware/libosmocore/include/osmocom/core/backtrace.h | 4 | ||||
-rw-r--r-- | firmware/libosmocore/include/osmocom/core/bit16gen.h | 105 | ||||
-rw-r--r-- | firmware/libosmocore/include/osmocom/core/bit32gen.h | 105 | ||||
-rw-r--r-- | firmware/libosmocore/include/osmocom/core/bit64gen.h | 105 | ||||
-rw-r--r-- | firmware/libosmocore/include/osmocom/core/bits.h | 118 | ||||
-rw-r--r-- | firmware/libosmocore/include/osmocom/core/defs.h | 47 | ||||
-rw-r--r-- | firmware/libosmocore/include/osmocom/core/msgb.h | 510 | ||||
-rw-r--r-- | firmware/libosmocore/include/osmocom/core/panic.h | 17 | ||||
-rw-r--r-- | firmware/libosmocore/include/osmocom/core/talloc.h | 4 | ||||
-rw-r--r-- | firmware/libosmocore/include/osmocom/core/utils.h | 92 | ||||
-rw-r--r-- | firmware/libosmocore/source/backtrace.c | 92 | ||||
-rw-r--r-- | firmware/libosmocore/source/bits.c | 307 | ||||
-rw-r--r-- | firmware/libosmocore/source/msgb.c | 353 | ||||
-rw-r--r-- | firmware/libosmocore/source/panic.c | 102 |
14 files changed, 1961 insertions, 0 deletions
diff --git a/firmware/libosmocore/include/osmocom/core/backtrace.h b/firmware/libosmocore/include/osmocom/core/backtrace.h new file mode 100644 index 0000000..0c9b6ef --- /dev/null +++ b/firmware/libosmocore/include/osmocom/core/backtrace.h @@ -0,0 +1,4 @@ +#pragma once + +void osmo_generate_backtrace(void); +void osmo_log_backtrace(int subsys, int level); diff --git a/firmware/libosmocore/include/osmocom/core/bit16gen.h b/firmware/libosmocore/include/osmocom/core/bit16gen.h new file mode 100644 index 0000000..5c6162c --- /dev/null +++ b/firmware/libosmocore/include/osmocom/core/bit16gen.h @@ -0,0 +1,105 @@ +/* + * bit16gen.h + * + * Copyright (C) 2014 Max <max.suraev@fairwaves.co> + * + * All Rights Reserved + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#pragma once + +/*! \brief load unaligned n-byte integer (little-endian encoding) into uint16_t + * \param[in] p Buffer where integer is stored + * \param[in] n Number of bytes stored in p + * \returns 16 bit unsigned integer + */ +static inline uint16_t osmo_load16le_ext(const void *p, uint8_t n) +{ + uint8_t i; + uint16_t r = 0; + const uint8_t *q = (uint8_t *)p; + for(i = 0; i < n; r |= ((uint16_t)q[i] << (8 * i)), i++); + return r; +} + +/*! \brief load unaligned n-byte integer (big-endian encoding) into uint16_t + * \param[in] p Buffer where integer is stored + * \param[in] n Number of bytes stored in p + * \returns 16 bit unsigned integer + */ +static inline uint16_t osmo_load16be_ext(const void *p, uint8_t n) +{ + uint8_t i; + uint16_t r = 0; + const uint8_t *q = (uint8_t *)p; + for(i = 0; i < n; r |= ((uint16_t)q[i] << (16 - 8* (1 + i))), i++); + return r; +} + + +/*! \brief store unaligned n-byte integer (little-endian encoding) from uint16_t + * \param[in] x unsigned 16 bit integer + * \param[out] p Buffer to store integer + * \param[in] n Number of bytes to store + */ +static inline void osmo_store16le_ext(uint16_t x, void *p, uint8_t n) +{ + uint8_t i; + uint8_t *q = (uint8_t *)p; + for(i = 0; i < n; q[i] = (x >> i * 8) & 0xFF, i++); +} + +/*! \brief store unaligned n-byte integer (big-endian encoding) from uint16_t + * \param[in] x unsigned 16 bit integer + * \param[out] p Buffer to store integer + * \param[in] n Number of bytes to store + */ +static inline void osmo_store16be_ext(uint16_t x, void *p, uint8_t n) +{ + uint8_t i; + uint8_t *q = (uint8_t *)p; + for(i = 0; i < n; q[i] = (x >> ((n - 1 - i) * 8)) & 0xFF, i++); +} + + +/* Convenience function for most-used cases */ + + +/*! \brief load unaligned 16-bit integer (little-endian encoding) */ +static inline uint16_t osmo_load16le(const void *p) +{ + return osmo_load16le_ext(p, 16 / 8); +} + +/*! \brief load unaligned 16-bit integer (big-endian encoding) */ +static inline uint16_t osmo_load16be(const void *p) +{ + return osmo_load16be_ext(p, 16 / 8); +} + + +/*! \brief store unaligned 16-bit integer (little-endian encoding) */ +static inline void osmo_store16le(uint16_t x, void *p) +{ + osmo_store16le_ext(x, p, 16 / 8); +} + +/*! \brief store unaligned 16-bit integer (big-endian encoding) */ +static inline void osmo_store16be(uint16_t x, void *p) +{ + osmo_store16be_ext(x, p, 16 / 8); +} diff --git a/firmware/libosmocore/include/osmocom/core/bit32gen.h b/firmware/libosmocore/include/osmocom/core/bit32gen.h new file mode 100644 index 0000000..6640e76 --- /dev/null +++ b/firmware/libosmocore/include/osmocom/core/bit32gen.h @@ -0,0 +1,105 @@ +/* + * bit32gen.h + * + * Copyright (C) 2014 Max <max.suraev@fairwaves.co> + * + * All Rights Reserved + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#pragma once + +/*! \brief load unaligned n-byte integer (little-endian encoding) into uint32_t + * \param[in] p Buffer where integer is stored + * \param[in] n Number of bytes stored in p + * \returns 32 bit unsigned integer + */ +static inline uint32_t osmo_load32le_ext(const void *p, uint8_t n) +{ + uint8_t i; + uint32_t r = 0; + const uint8_t *q = (uint8_t *)p; + for(i = 0; i < n; r |= ((uint32_t)q[i] << (8 * i)), i++); + return r; +} + +/*! \brief load unaligned n-byte integer (big-endian encoding) into uint32_t + * \param[in] p Buffer where integer is stored + * \param[in] n Number of bytes stored in p + * \returns 32 bit unsigned integer + */ +static inline uint32_t osmo_load32be_ext(const void *p, uint8_t n) +{ + uint8_t i; + uint32_t r = 0; + const uint8_t *q = (uint8_t *)p; + for(i = 0; i < n; r |= ((uint32_t)q[i] << (32 - 8* (1 + i))), i++); + return r; +} + + +/*! \brief store unaligned n-byte integer (little-endian encoding) from uint32_t + * \param[in] x unsigned 32 bit integer + * \param[out] p Buffer to store integer + * \param[in] n Number of bytes to store + */ +static inline void osmo_store32le_ext(uint32_t x, void *p, uint8_t n) +{ + uint8_t i; + uint8_t *q = (uint8_t *)p; + for(i = 0; i < n; q[i] = (x >> i * 8) & 0xFF, i++); +} + +/*! \brief store unaligned n-byte integer (big-endian encoding) from uint32_t + * \param[in] x unsigned 32 bit integer + * \param[out] p Buffer to store integer + * \param[in] n Number of bytes to store + */ +static inline void osmo_store32be_ext(uint32_t x, void *p, uint8_t n) +{ + uint8_t i; + uint8_t *q = (uint8_t *)p; + for(i = 0; i < n; q[i] = (x >> ((n - 1 - i) * 8)) & 0xFF, i++); +} + + +/* Convenience function for most-used cases */ + + +/*! \brief load unaligned 32-bit integer (little-endian encoding) */ +static inline uint32_t osmo_load32le(const void *p) +{ + return osmo_load32le_ext(p, 32 / 8); +} + +/*! \brief load unaligned 32-bit integer (big-endian encoding) */ +static inline uint32_t osmo_load32be(const void *p) +{ + return osmo_load32be_ext(p, 32 / 8); +} + + +/*! \brief store unaligned 32-bit integer (little-endian encoding) */ +static inline void osmo_store32le(uint32_t x, void *p) +{ + osmo_store32le_ext(x, p, 32 / 8); +} + +/*! \brief store unaligned 32-bit integer (big-endian encoding) */ +static inline void osmo_store32be(uint32_t x, void *p) +{ + osmo_store32be_ext(x, p, 32 / 8); +} diff --git a/firmware/libosmocore/include/osmocom/core/bit64gen.h b/firmware/libosmocore/include/osmocom/core/bit64gen.h new file mode 100644 index 0000000..8c7b709 --- /dev/null +++ b/firmware/libosmocore/include/osmocom/core/bit64gen.h @@ -0,0 +1,105 @@ +/* + * bit64gen.h + * + * Copyright (C) 2014 Max <max.suraev@fairwaves.co> + * + * All Rights Reserved + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#pragma once + +/*! \brief load unaligned n-byte integer (little-endian encoding) into uint64_t + * \param[in] p Buffer where integer is stored + * \param[in] n Number of bytes stored in p + * \returns 64 bit unsigned integer + */ +static inline uint64_t osmo_load64le_ext(const void *p, uint8_t n) +{ + uint8_t i; + uint64_t r = 0; + const uint8_t *q = (uint8_t *)p; + for(i = 0; i < n; r |= ((uint64_t)q[i] << (8 * i)), i++); + return r; +} + +/*! \brief load unaligned n-byte integer (big-endian encoding) into uint64_t + * \param[in] p Buffer where integer is stored + * \param[in] n Number of bytes stored in p + * \returns 64 bit unsigned integer + */ +static inline uint64_t osmo_load64be_ext(const void *p, uint8_t n) +{ + uint8_t i; + uint64_t r = 0; + const uint8_t *q = (uint8_t *)p; + for(i = 0; i < n; r |= ((uint64_t)q[i] << (64 - 8* (1 + i))), i++); + return r; +} + + +/*! \brief store unaligned n-byte integer (little-endian encoding) from uint64_t + * \param[in] x unsigned 64 bit integer + * \param[out] p Buffer to store integer + * \param[in] n Number of bytes to store + */ +static inline void osmo_store64le_ext(uint64_t x, void *p, uint8_t n) +{ + uint8_t i; + uint8_t *q = (uint8_t *)p; + for(i = 0; i < n; q[i] = (x >> i * 8) & 0xFF, i++); +} + +/*! \brief store unaligned n-byte integer (big-endian encoding) from uint64_t + * \param[in] x unsigned 64 bit integer + * \param[out] p Buffer to store integer + * \param[in] n Number of bytes to store + */ +static inline void osmo_store64be_ext(uint64_t x, void *p, uint8_t n) +{ + uint8_t i; + uint8_t *q = (uint8_t *)p; + for(i = 0; i < n; q[i] = (x >> ((n - 1 - i) * 8)) & 0xFF, i++); +} + + +/* Convenience function for most-used cases */ + + +/*! \brief load unaligned 64-bit integer (little-endian encoding) */ +static inline uint64_t osmo_load64le(const void *p) +{ + return osmo_load64le_ext(p, 64 / 8); +} + +/*! \brief load unaligned 64-bit integer (big-endian encoding) */ +static inline uint64_t osmo_load64be(const void *p) +{ + return osmo_load64be_ext(p, 64 / 8); +} + + +/*! \brief store unaligned 64-bit integer (little-endian encoding) */ +static inline void osmo_store64le(uint64_t x, void *p) +{ + osmo_store64le_ext(x, p, 64 / 8); +} + +/*! \brief store unaligned 64-bit integer (big-endian encoding) */ +static inline void osmo_store64be(uint64_t x, void *p) +{ + osmo_store64be_ext(x, p, 64 / 8); +} diff --git a/firmware/libosmocore/include/osmocom/core/bits.h b/firmware/libosmocore/include/osmocom/core/bits.h new file mode 100644 index 0000000..5535920 --- /dev/null +++ b/firmware/libosmocore/include/osmocom/core/bits.h @@ -0,0 +1,118 @@ +#pragma once + +#include <stdint.h> +#include <stddef.h> + +#include <osmocom/core/bit16gen.h> +#include <osmocom/core/bit32gen.h> +#include <osmocom/core/bit64gen.h> + +/*! \defgroup bits soft, unpacked and packed bits + * @{ + */ + +/*! \file bits.h + * \brief Osmocom bit level support code + * + * NOTE on the endianess of pbit_t: + * Bits in a pbit_t are ordered MSB first, i.e. 0x80 is the first bit. + * Bit i in a pbit_t array is array[i/8] & (1<<(7-i%8)) + */ + +typedef int8_t sbit_t; /*!< \brief soft bit (-127...127) */ +typedef uint8_t ubit_t; /*!< \brief unpacked bit (0 or 1) */ +typedef uint8_t pbit_t; /*!< \brief packed bis (8 bits in a byte) */ + +/*! \brief determine how many bytes we would need for \a num_bits packed bits + * \param[in] num_bits Number of packed bits + * \returns number of bytes needed for \a num_bits packed bits + */ +static inline unsigned int osmo_pbit_bytesize(unsigned int num_bits) +{ + unsigned int pbit_bytesize = num_bits / 8; + + if (num_bits % 8) + pbit_bytesize++; + + return pbit_bytesize; +} + +int osmo_ubit2pbit(pbit_t *out, const ubit_t *in, unsigned int num_bits); + +int osmo_pbit2ubit(ubit_t *out, const pbit_t *in, unsigned int num_bits); + +void osmo_nibble_shift_right(uint8_t *out, const uint8_t *in, + unsigned int num_nibbles); +void osmo_nibble_shift_left_unal(uint8_t *out, const uint8_t *in, + unsigned int num_nibbles); + +void osmo_ubit2sbit(sbit_t *out, const ubit_t *in, unsigned int num_bits); +void osmo_sbit2ubit(ubit_t *out, const sbit_t *in, unsigned int num_bits); + +int osmo_ubit2pbit_ext(pbit_t *out, unsigned int out_ofs, + const ubit_t *in, unsigned int in_ofs, + unsigned int num_bits, int lsb_mode); + +int osmo_pbit2ubit_ext(ubit_t *out, unsigned int out_ofs, + const pbit_t *in, unsigned int in_ofs, + unsigned int num_bits, int lsb_mode); + +#define OSMO_BIN_SPEC "%d%d%d%d%d%d%d%d" +#define OSMO_BIN_PRINT(byte) \ + (byte & 0x80 ? 1 : 0), \ + (byte & 0x40 ? 1 : 0), \ + (byte & 0x20 ? 1 : 0), \ + (byte & 0x10 ? 1 : 0), \ + (byte & 0x08 ? 1 : 0), \ + (byte & 0x04 ? 1 : 0), \ + (byte & 0x02 ? 1 : 0), \ + (byte & 0x01 ? 1 : 0) + +#define OSMO_BIT_SPEC "%c%c%c%c%c%c%c%c" +#define OSMO_BIT_PRINT(byte) \ + (byte & 0x80 ? '1' : '.'), \ + (byte & 0x40 ? '1' : '.'), \ + (byte & 0x20 ? '1' : '.'), \ + (byte & 0x10 ? '1' : '.'), \ + (byte & 0x08 ? '1' : '.'), \ + (byte & 0x04 ? '1' : '.'), \ + (byte & 0x02 ? '1' : '.'), \ + (byte & 0x01 ? '1' : '.') + +/* BIT REVERSAL */ + +/*! \brief bit-reversal mode for osmo_bit_reversal() */ +enum osmo_br_mode { + /*! \brief reverse all bits in a 32bit dword */ + OSMO_BR_BITS_IN_DWORD = 31, + /*! \brief reverse byte order in a 32bit dword */ + OSMO_BR_BYTES_IN_DWORD = 24, + /*! \brief reverse bits of each byte in a 32bit dword */ + OSMO_BR_BITS_IN_BYTE = 7, + /*! \brief swap the two 16bit words in a 32bit dword */ + OSMO_BR_WORD_SWAP = 16, +}; + +/*! \brief generic bit reversal function */ +uint32_t osmo_bit_reversal(uint32_t x, enum osmo_br_mode k); + +/* \brief reverse the bits within each byte of a 32bit word */ +uint32_t osmo_revbytebits_32(uint32_t x); + +/* \brief reverse the bits within a byte */ +uint32_t osmo_revbytebits_8(uint8_t x); + +/* \brief reverse the bits of each byte in a given buffer */ +void osmo_revbytebits_buf(uint8_t *buf, int len); + +/*! \brief left circular shift + * \param[in] in The 16 bit unsigned integer to be rotated + * \param[in] shift Number of bits to shift \a in to, [0;16] bits + * \returns shifted value + */ +static inline uint16_t osmo_rol16(uint16_t in, unsigned shift) +{ + return (in << shift) | (in >> (16 - shift)); +} + +/*! @} */ diff --git a/firmware/libosmocore/include/osmocom/core/defs.h b/firmware/libosmocore/include/osmocom/core/defs.h new file mode 100644 index 0000000..aebe925 --- /dev/null +++ b/firmware/libosmocore/include/osmocom/core/defs.h @@ -0,0 +1,47 @@ +#pragma once + +/*! \defgroup utils General-purpose utility functions + * @{ + */ + +/*! \file defs.h + * \brief General definitions that are meant to be included from header files. + */ + +/*! \brief Check for gcc and version. + * + * \note Albeit glibc provides a features.h file that contains a similar + * definition (__GNUC_PREREQ), this definition has been copied from there + * to have it available with other libraries, too. + * + * \return != 0 iff gcc is used and it's version is at least maj.min. + */ +#if defined __GNUC__ && defined __GNUC_MINOR__ +# define OSMO_GNUC_PREREQ(maj, min) \ + ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min)) +#else +# define OSMO_GNUC_PREREQ(maj, min) 0 +#endif + +/*! \brief Set the deprecated attribute with a message. + */ +#if defined(__clang__) +# define _OSMO_HAS_ATTRIBUTE_DEPRECATED __has_attribute(deprecated) +# define _OSMO_HAS_ATTRIBUTE_DEPRECATED_WITH_MESSAGE __has_extension(attribute_deprecated_with_message) +#elif defined(__GNUC__) +# define _OSMO_HAS_ATTRIBUTE_DEPRECATED 1 +# define _OSMO_HAS_ATTRIBUTE_DEPRECATED_WITH_MESSAGE OSMO_GNUC_PREREQ(4,5) +#endif + +#if _OSMO_HAS_ATTRIBUTE_DEPRECATED_WITH_MESSAGE +# define OSMO_DEPRECATED(text) __attribute__((__deprecated__(text))) +#elif _OSMO_HAS_ATTRIBUTE_DEPRECATED +# define OSMO_DEPRECATED(text) __attribute__((__deprecated__)) +#else +# define OSMO_DEPRECATED(text) +#endif + +#undef _OSMO_HAS_ATTRIBUTE_DEPRECATED_WITH_MESSAGE +#undef _OSMO_HAS_ATTRIBUTE_DEPRECATED + +/*! @} */ diff --git a/firmware/libosmocore/include/osmocom/core/msgb.h b/firmware/libosmocore/include/osmocom/core/msgb.h new file mode 100644 index 0000000..afb887c --- /dev/null +++ b/firmware/libosmocore/include/osmocom/core/msgb.h @@ -0,0 +1,510 @@ +#pragma once + +/* (C) 2008 by Harald Welte <laforge@gnumonks.org> + * All Rights Reserved + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + * + */ + +#include <stdint.h> +#include <osmocom/core/linuxlist.h> +#include <osmocom/core/utils.h> +#include <osmocom/core/bits.h> +#include <osmocom/core/defs.h> + +/*! \defgroup msgb Message buffers + * @{ + */ + +/*! \file msgb.h + * \brief Osmocom message buffers + * The Osmocom message buffers are modelled after the 'struct skb' + * inside the Linux kernel network stack. As they exist in userspace, + * they are much simplified. However, terminology such as headroom, + * tailroom, push/pull/put etc. remains the same. + */ + +#define MSGB_DEBUG + +/*! \brief Osmocom message buffer */ +struct msgb { + struct llist_head list; /*!< \brief linked list header */ + + + /* Part of which TRX logical channel we were received / transmitted */ + /* FIXME: move them into the control buffer */ + union { + void *dst; /*!< \brief reference of origin/destination */ + struct gsm_bts_trx *trx; + }; + struct gsm_lchan *lchan; /*!< \brief logical channel */ + + unsigned char *l1h; /*!< \brief pointer to Layer1 header (if any) */ + unsigned char *l2h; /*!< \brief pointer to A-bis layer 2 header: OML, RSL(RLL), NS */ + unsigned char *l3h; /*!< \brief pointer to Layer 3 header. For OML: FOM; RSL: 04.08; GPRS: BSSGP */ + unsigned char *l4h; /*!< \brief pointer to layer 4 header */ + + unsigned long cb[5]; /*!< \brief control buffer */ + + uint16_t data_len; /*!< \brief length of underlying data array */ + uint16_t len; /*!< \brief length of bytes used in msgb */ + + unsigned char *head; /*!< \brief start of underlying memory buffer */ + unsigned char *tail; /*!< \brief end of message in buffer */ + unsigned char *data; /*!< \brief start of message in buffer */ + unsigned char _data[0]; /*!< \brief optional immediate data array */ +}; + +extern struct msgb *msgb_alloc(uint16_t size, const char *name); +extern void msgb_free(struct msgb *m); +extern void msgb_enqueue(struct llist_head *queue, struct msgb *msg); +extern struct msgb *msgb_dequeue(struct llist_head *queue); +extern void msgb_reset(struct msgb *m); +uint16_t msgb_length(const struct msgb *msg); +extern const char *msgb_hexdump(const struct msgb *msg); +extern int msgb_resize_area(struct msgb *msg, uint8_t *area, + int old_size, int new_size); +extern struct msgb *msgb_copy(const struct msgb *msg, const char *name); +static int msgb_test_invariant(const struct msgb *msg) __attribute__((pure)); + +#ifdef MSGB_DEBUG +#include <osmocom/core/panic.h> +#define MSGB_ABORT(msg, fmt, args ...) do { \ + osmo_panic("msgb(%p): " fmt, msg, ## args); \ + } while(0) +#else +#define MSGB_ABORT(msg, fmt, args ...) +#endif + +/*! \brief obtain L1 header of msgb */ +#define msgb_l1(m) ((void *)(m->l1h)) +/*! \brief obtain L2 header of msgb */ +#define msgb_l2(m) ((void *)(m->l2h)) +/*! \brief obtain L3 header of msgb */ +#define msgb_l3(m) ((void *)(m->l3h)) +/*! \brief obtain SMS header of msgb */ +#define msgb_sms(m) ((void *)(m->l4h)) + +/*! \brief determine length of L1 message + * \param[in] msgb message buffer + * \returns size of L1 message in bytes + * + * This function computes the number of bytes between the tail of the + * message and the layer 1 header. + */ +static inline unsigned int msgb_l1len(const struct msgb *msgb) +{ + return msgb->tail - (uint8_t *)msgb_l1(msgb); +} + +/*! \brief determine length of L2 message + * \param[in] msgb message buffer + * \returns size of L2 message in bytes + * + * This function computes the number of bytes between the tail of the + * message and the layer 2 header. + */ +static inline unsigned int msgb_l2len(const struct msgb *msgb) +{ + return msgb->tail - (uint8_t *)msgb_l2(msgb); +} + +/*! \brief determine length of L3 message + * \param[in] msgb message buffer + * \returns size of L3 message in bytes + * + * This function computes the number of bytes between the tail of the + * message and the layer 3 header. + */ +static inline unsigned int msgb_l3len(const struct msgb *msgb) +{ + return msgb->tail - (uint8_t *)msgb_l3(msgb); +} + +/*! \brief determine the length of the header + * \param[in] msgb message buffer + * \returns number of bytes between start of buffer and start of msg + * + * This function computes the length difference between the underlying + * data buffer and the used section of the \a msgb. + */ +static inline unsigned int msgb_headlen(const struct msgb *msgb) +{ + return msgb->len - msgb->data_len; +} + +/*! \brief determine how much tail room is left in msgb + * \param[in] msgb message buffer + * \returns number of bytes remaining at end of msgb + * + * This function computes the amount of octets left in the underlying + * data buffer after the end of the message. + */ +static inline int msgb_tailroom(const struct msgb *msgb) +{ + return (msgb->head + msgb->data_len) - msgb->tail; +} + +/*! \brief determine the amount of headroom in msgb + * \param[in] msgb message buffer + * \returns number of bytes left ahead of message start in msgb + * + * This function computes the amount of bytes left in the underlying + * data buffer before the start of the actual message. + */ +static inline int msgb_headroom(const struct msgb *msgb) +{ + return (msgb->data - msgb->head); +} + +/*! \brief append data to end of message buffer + * \param[in] msgb message buffer + * \param[in] len number of bytes to append to message + * \returns pointer to start of newly-appended data + * + * This function will move the \a tail pointer of the message buffer \a + * len bytes further, thus enlarging the message by \a len bytes. + * + * The return value is a pointer to start of the newly added section at + * the end of the message and can be used for actually filling/copying + * data into it. + */ +static inline unsigned char *msgb_put(struct msgb *msgb, unsigned int len) +{ + unsigned char *tmp = msgb->tail; + if (msgb_tailroom(msgb) < (int) len) + MSGB_ABORT(msgb, "Not enough tailroom msgb_put (%u < %u)\n", + msgb_tailroom(msgb), len); + msgb->tail += len; + msgb->len += len; + return tmp; +} + +/*! \brief append a uint8 value to the end of the message + * \param[in] msgb message buffer + * \param[in] word unsigned 8bit byte to be appended + */ +static inline void msgb_put_u8(struct msgb *msgb, uint8_t word) +{ + uint8_t *space = msgb_put(msgb, 1); + space[0] = word & 0xFF; +} + +/*! \brief append a uint16 value to the end of the message + * \param[in] msgb message buffer + * \param[in] word unsigned 16bit byte to be appended + */ +static inline void msgb_put_u16(struct msgb *msgb, uint16_t word) +{ + uint8_t *space = msgb_put(msgb, 2); + osmo_store16be(word, space); +} + +/*! \brief append a uint32 value to the end of the message + * \param[in] msgb message buffer + * \param[in] word unsigned 32bit byte to be appended + */ +static inline void msgb_put_u32(struct msgb *msgb, uint32_t word) +{ + uint8_t *space = msgb_put(msgb, 4); + osmo_store32be(word, space); +} + +/*! \brief remove data from end of message + * \param[in] msgb message buffer + * \param[in] len number of bytes to remove from end + */ +static inline unsigned char *msgb_get(struct msgb *msgb, unsigned int len) +{ + unsigned char *tmp = msgb->tail - len; + if (msgb_length(msgb) < len) + MSGB_ABORT(msgb, "msgb too small to get %u (len %u)\n", + len, msgb_length(msgb)); + msgb->tail -= len; + msgb->len -= len; + return tmp; +} + +/*! \brief remove uint8 from end of message + * \param[in] msgb message buffer + * \returns 8bit value taken from end of msgb + */ +static inline uint8_t msgb_get_u8(struct msgb *msgb) +{ + uint8_t *space = msgb_get(msgb, 1); + return space[0]; +} + +/*! \brief remove uint16 from end of message + * \param[in] msgb message buffer + * \returns 16bit value taken from end of msgb + */ +static inline uint16_t msgb_get_u16(struct msgb *msgb) +{ + uint8_t *space = msgb_get(msgb, 2); + return osmo_load16be(space); +} + +/*! \brief remove uint32 from end of message + * \param[in] msgb message buffer + * \returns 32bit value taken from end of msgb + */ +static inline uint32_t msgb_get_u32(struct msgb *msgb) +{ + uint8_t *space = msgb_get(msgb, 4); + return osmo_load32be(space); +} + +/*! \brief prepend (push) some data to start of message + * \param[in] msgb message buffer + * \param[in] len number of bytes to pre-pend + * \returns pointer to newly added portion at start of \a msgb + * + * This function moves the \a data pointer of the \ref msgb further + * to the front (by \a len bytes), thereby enlarging the message by \a + * len bytes. + * + * The return value is a pointer to the newly added section in the + * beginning of the message. It can be used to fill/copy data into it. + */ +static inline unsigned char *msgb_push(struct msgb *msgb, unsigned int len) +{ + if (msgb_headroom(msgb) < (int) len) + MSGB_ABORT(msgb, "Not enough headroom msgb_push (%u < %u)\n", + msgb_headroom(msgb), len); + msgb->data -= len; + msgb->len += len; + return msgb->data; +} + +/*! \brief prepend a uint8 value to the head of the message + * \param[in] msgb message buffer + * \param[in] word unsigned 8bit byte to be prepended + */ +static inline void msgb_push_u8(struct msgb *msg, uint8_t word) +{ + uint8_t *space = msgb_push(msg, 1); + space[0] = word; +} + +/*! \brief prepend a uint16 value to the head of the message + * \param[in] msgb message buffer + * \param[in] word unsigned 16bit byte to be prepended + */ +static inline void msgb_push_u16(struct msgb *msg, uint16_t word) +{ + uint16_t *space = (uint16_t *) msgb_push(msg, 2); + osmo_store16be(word, space); +} + +/*! \brief prepend a uint32 value to the head of the message + * \param[in] msgb message buffer + * \param[in] word unsigned 32bit byte to be prepended + */ +static inline void msgb_push_u32(struct msgb *msg, uint32_t word) +{ + uint32_t *space = (uint32_t *) msgb_push(msg, 4); + osmo_store32be(word, space); +} + +/*! \brief remove (pull) a header from the front of the message buffer + * \param[in] msgb message buffer + * \param[in] len number of octets to be pulled + * \returns pointer to new start of msgb + * + * This function moves the \a data pointer of the \ref msgb further back + * in the message, thereby shrinking the size of the message by \a len + * bytes. + */ +static inline unsigned char *msgb_pull(struct msgb *msgb, unsigned int len) +{ + msgb->len -= len; + return msgb->data += len; +} + +/*! \brief remove (pull) all headers in front of l3h from the message buffer. + * \param[in] msgb message buffer with a valid l3h + * \returns pointer to new start of msgb (l3h) + * + * This function moves the \a data pointer of the \ref msgb further back + * in the message, thereby shrinking the size of the message. + * l1h and l2h will be cleared. + */ +static inline unsigned char *msgb_pull_to_l3(struct msgb *msg) +{ + unsigned char *ret = msgb_pull(msg, msg->l3h - msg->data); + msg->l1h = msg->l2h = NULL; + return ret; +} + +/*! \brief remove (pull) all headers in front of l2h from the message buffer. + * \param[in] msgb message buffer with a valid l2h + * \returns pointer to new start of msgb (l2h) + * + * This function moves the \a data pointer of the \ref msgb further back + * in the message, thereby shrinking the size of the message. + * l1h will be cleared. + */ +static inline unsigned char *msgb_pull_to_l2(struct msgb *msg) +{ + unsigned char *ret = msgb_pull(msg, msg->l2h - msg->data); + msg->l1h = NULL; + return ret; +} + +/*! \brief remove uint8 from front of message + * \param[in] msgb message buffer + * \returns 8bit value taken from end of msgb + */ +static inline uint8_t msgb_pull_u8(struct msgb *msgb) +{ + uint8_t *space = msgb_pull(msgb, 1) - 1; + return space[0]; +} + +/*! \brief remove uint16 from front of message + * \param[in] msgb message buffer + * \returns 16bit value taken from end of msgb + */ +static inline uint16_t msgb_pull_u16(struct msgb *msgb) +{ + uint8_t *space = msgb_pull(msgb, 2) - 2; + return osmo_load16be(space); +} + +/*! \brief remove uint32 from front of message + * \param[in] msgb message buffer + * \returns 32bit value taken from end of msgb + */ +static inline uint32_t msgb_pull_u32(struct msgb *msgb) +{ + uint8_t *space = msgb_pull(msgb, 4) - 4; + return osmo_load32be(space); +} + +/*! \brief Increase headroom of empty msgb, reducing the tailroom + * \param[in] msg message buffer + * \param[in] len amount of extra octets to be reserved as headroom + * + * This function reserves some memory at the beginning of the underlying + * data buffer. The idea is to reserve space in case further headers + * have to be pushed to the \ref msgb during further processing. + * + * Calling this function leads to undefined reusults if it is called on + * a non-empty \ref msgb. + */ +static inline void msgb_reserve(struct msgb *msg, int len) +{ + msg->data += len; + msg->tail += len; +} + +/*! \brief Trim the msgb to a given absolute length + * \param[in] msg message buffer + * \param[in] len new total length of buffer + * \returns 0 in case of success, negative in case of error + */ +static inline int msgb_trim(struct msgb *msg, int len) +{ + if (len < 0) + MSGB_ABORT(msg, "Negative length is not allowed\n"); + if (len > msg->data_len) + return -1; + + msg->len = len; + msg->tail = msg->data + len; + + return 0; +} + +/*! \brief Trim the msgb to a given layer3 length + * \param[in] msg message buffer + * \param[in] l3len new layer3 length + * \returns 0 in case of success, negative in case of error + */ +static inline int msgb_l3trim(struct msgb *msg, int l3len) +{ + return msgb_trim(msg, (msg->l3h - msg->data) + l3len); +} + +/*! \brief Allocate message buffer with specified headroom + * \param[in] size size in bytes, including headroom + * \param[in] headroom headroom in bytes + * \param[in] name human-readable name + * \returns allocated message buffer with specified headroom + * + * This function is a convenience wrapper around \ref msgb_alloc + * followed by \ref msgb_reserve in order to create a new \ref msgb with + * user-specified amount of headroom. + */ +static inline struct msgb *msgb_alloc_headroom(int size, int headroom, + const char *name) +{ + osmo_static_assert(size > headroom, headroom_bigger); + + struct msgb *msg = msgb_alloc(size, name); + if (msg) + msgb_reserve(msg, headroom); + return msg; +} + +/*! \brief Check a message buffer for consistency + * \param[in] msg message buffer + * \returns 0 (false) if inconsistent, != 0 (true) otherwise + */ +static inline int msgb_test_invariant(const struct msgb *msg) +{ + const unsigned char *lbound; + if (!msg || !msg->data || !msg->tail || + (msg->data + msg->len != msg->tail) || + (msg->data < msg->head) || + (msg->tail > msg->head + msg->data_len)) + return 0; + + lbound = msg->head; + + if (msg->l1h) { + if (msg->l1h < lbound) + return 0; + lbound = msg->l1h; + } + if (msg->l2h) { + if (msg->l2h < lbound) + return 0; + lbound = msg->l2h; + } + if (msg->l3h) { + if (msg->l3h < lbound) + return 0; + lbound = msg->l3h; + } + if (msg->l4h) { + if (msg->l4h < lbound) + return 0; + lbound = msg->l4h; + } + + return lbound <= msg->head + msg->data_len; +} + +/* non inline functions to ease binding */ + +uint8_t *msgb_data(const struct msgb *msg); + +void *msgb_talloc_ctx_init(void *root_ctx, unsigned int pool_size); +void msgb_set_talloc_ctx(void *ctx) OSMO_DEPRECATED("Use msgb_talloc_ctx_init() instead"); + +/*! @} */ diff --git a/firmware/libosmocore/include/osmocom/core/panic.h b/firmware/libosmocore/include/osmocom/core/panic.h new file mode 100644 index 0000000..5d575c4 --- /dev/null +++ b/firmware/libosmocore/include/osmocom/core/panic.h @@ -0,0 +1,17 @@ +#pragma once + +/*! \addtogroup utils + * @{ + */ + +/*! \file panic.h */ + +#include <stdarg.h> + +/*! \brief panic handler callback function type */ +typedef void (*osmo_panic_handler_t)(const char *fmt, va_list args); + +extern void osmo_panic(const char *fmt, ...); +extern void osmo_set_panic_handler(osmo_panic_handler_t h); + +/*! @} */ diff --git a/firmware/libosmocore/include/osmocom/core/talloc.h b/firmware/libosmocore/include/osmocom/core/talloc.h new file mode 100644 index 0000000..df7ea7f --- /dev/null +++ b/firmware/libosmocore/include/osmocom/core/talloc.h @@ -0,0 +1,4 @@ +/* Convenience wrapper. libosmocore used to ship its own internal copy of + * talloc, before libtalloc became a standard component on most systems */ +#pragma once +#include <talloc.h> diff --git a/firmware/libosmocore/include/osmocom/core/utils.h b/firmware/libosmocore/include/osmocom/core/utils.h new file mode 100644 index 0000000..63a73ab --- /dev/null +++ b/firmware/libosmocore/include/osmocom/core/utils.h @@ -0,0 +1,92 @@ +#pragma once + +#include <osmocom/core/backtrace.h> +#include <osmocom/core/talloc.h> + +/*! \defgroup utils General-purpose utility functions + * @{ + */ + +/*! \file utils.h */ + +/*! \brief Determine number of elements in an array of static size */ +#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) +/*! \brief Return the maximum of two specified values */ +#define OSMO_MAX(a, b) ((a) >= (b) ? (a) : (b)) +/*! \brief Return the minimum of two specified values */ +#define OSMO_MIN(a, b) ((a) >= (b) ? (b) : (a)) +/*! \brief Stringify the contents of a macro, e.g. a port number */ +#define OSMO_STRINGIFY(x) #x +/*! \brief Make a value_string entry from an enum value name */ +#define OSMO_VALUE_STRING(x) { x, #x } + +#include <stdint.h> +#include <stdio.h> + +/*! \brief A mapping between human-readable string and numeric value */ +struct value_string { + unsigned int value; /*!< \brief numeric value */ + const char *str; /*!< \brief human-readable string */ +}; + +const char *get_value_string(const struct value_string *vs, uint32_t val); +const char *get_value_string_or_null(const struct value_string *vs, + uint32_t val); + +int get_string_value(const struct value_string *vs, const char *str); + +char osmo_bcd2char(uint8_t bcd); +/* only works for numbers in ascci */ +uint8_t osmo_char2bcd(char c); + +int osmo_hexparse(const char *str, uint8_t *b, int max_len); + +char *osmo_ubit_dump(const uint8_t *bits, unsigned int len); +char *osmo_hexdump(const unsigned char *buf, int len); +char *osmo_hexdump_nospc(const unsigned char *buf, int len); +char *osmo_osmo_hexdump_nospc(const unsigned char *buf, int len) __attribute__((__deprecated__)); + +#define osmo_static_assert(exp, name) typedef int dummy##name [(exp) ? 1 : -1] __attribute__((__unused__)); + +void osmo_str2lower(char *out, const char *in); +void osmo_str2upper(char *out, const char *in); + +#define OSMO_SNPRINTF_RET(ret, rem, offset, len) \ +do { \ + len += ret; \ + if (ret > rem) \ + ret = rem; \ + offset += ret; \ + rem -= ret; \ +} while (0) + +/*! Helper macro to terminate when an assertion failes + * \param[in] exp Predicate to verify + * This function will generate a backtrace and terminate the program if + * the predicate evaluates to false (0). + */ +#define OSMO_ASSERT(exp) \ + if (!(exp)) { \ + fprintf(stderr, "Assert failed %s %s:%d\n", #exp, __BASE_FILE__, __LINE__); \ + osmo_generate_backtrace(); \ + abort(); \ + } + +/*! duplicate a string using talloc and release its prior content (if any) + * \param[in] ctx Talloc context to use for allocation + * \param[out] dst pointer to string, will be updated with ptr to new string + * \param[in] newstr String that will be copieed to newly allocated string */ +static inline void osmo_talloc_replace_string(void *ctx, char **dst, const char *newstr) +{ + if (*dst) + talloc_free(*dst); + *dst = talloc_strdup(ctx, newstr); +} + +int osmo_constant_time_cmp(const uint8_t *exp, const uint8_t *rel, const int count); +uint64_t osmo_decode_big_endian(const uint8_t *data, size_t data_len); +uint8_t *osmo_encode_big_endian(uint64_t value, size_t data_len); + +size_t osmo_strlcpy(char *dst, const char *src, size_t siz); + +/*! @} */ diff --git a/firmware/libosmocore/source/backtrace.c b/firmware/libosmocore/source/backtrace.c new file mode 100644 index 0000000..5d6dc4a --- /dev/null +++ b/firmware/libosmocore/source/backtrace.c @@ -0,0 +1,92 @@ +/* + * (C) 2009 by Holger Hans Peter Freyther <zecke@selfish.org> + * (C) 2012 by Harald Welte <laforge@gnumonks.org> + * + * All Rights Reserved + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + * + */ + +/*! \file backtrace.c + * \brief Routines realted to generating call back traces + */ + +#include <stdio.h> +#include <stdlib.h> +#include <osmocom/core/utils.h> +//#include <osmocom/core/logging.h> +//#include "config.h" + +#ifdef HAVE_EXECINFO_H +#include <execinfo.h> + +static void _osmo_backtrace(int use_printf, int subsys, int level) +{ + int i, nptrs; + void *buffer[100]; + char **strings; + + nptrs = backtrace(buffer, ARRAY_SIZE(buffer)); + if (use_printf) + printf("backtrace() returned %d addresses\n", nptrs); + else + LOGP(subsys, level, "backtrace() returned %d addresses\n", + nptrs); + + strings = backtrace_symbols(buffer, nptrs); + if (!strings) + return; + + for (i = 1; i < nptrs; i++) { + if (use_printf) + printf("%s\n", strings[i]); + else + LOGP(subsys, level, "\t%s\n", strings[i]); + } + + free(strings); +} + +/*! \brief Generate and print a call back-trace + * + * This function will generate a function call back-trace of the + * current process and print it to stdout. */ +void osmo_generate_backtrace(void) +{ + _osmo_backtrace(1, 0, 0); +} + +/*! \brief Generate and log a call back-trace + * \param[in] subsys Logging sub-system + * \param[in] level Logging level + * + * This function will generate a function call back-trace of the + * current process and log it to the specified subsystem and + * level using the libosmocore logging subsystem */ +void osmo_log_backtrace(int subsys, int level) +{ + _osmo_backtrace(0, subsys, level); +} +#else +void osmo_generate_backtrace(void) +{ + printf("This platform has no backtrace function\n"); +} +void osmo_log_backtrace(int subsys, int level) +{ + //LOGP(subsys, level, "This platform has no backtrace function\n"); +} +#endif diff --git a/firmware/libosmocore/source/bits.c b/firmware/libosmocore/source/bits.c new file mode 100644 index 0000000..0c77b27 --- /dev/null +++ b/firmware/libosmocore/source/bits.c @@ -0,0 +1,307 @@ +/* + * (C) 2011 by Harald Welte <laforge@gnumonks.org> + * (C) 2011 by Sylvain Munaut <tnt@246tNt.com> + * + * All Rights Reserved + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + * + */ + +#include <stdint.h> + +#include <osmocom/core/bits.h> + +/*! \addtogroup bits + * @{ + */ + +/*! \file bits.c + * \brief Osmocom bit level support code + */ + + +/*! \brief convert unpacked bits to packed bits, return length in bytes + * \param[out] out output buffer of packed bits + * \param[in] in input buffer of unpacked bits + * \param[in] num_bits number of bits + */ +int osmo_ubit2pbit(pbit_t *out, const ubit_t *in, unsigned int num_bits) +{ + unsigned int i; + uint8_t curbyte = 0; + pbit_t *outptr = out; + + for (i = 0; i < num_bits; i++) { + uint8_t bitnum = 7 - (i % 8); + + curbyte |= (in[i] << bitnum); + + if(i % 8 == 7){ + *outptr++ = curbyte; + curbyte = 0; + } + } + /* we have a non-modulo-8 bitcount */ + if (i % 8) + *outptr++ = curbyte; + + return outptr - out; +} + +/*! \brief Shift unaligned input to octet-aligned output + * \param[out] out output buffer, unaligned + * \param[in] in input buffer, octet-aligned + * \param[in] num_nibbles number of nibbles + */ +void osmo_nibble_shift_right(uint8_t *out, const uint8_t *in, + unsigned int num_nibbles) +{ + unsigned int i, num_whole_bytes = num_nibbles / 2; + if (!num_whole_bytes) + return; + + /* first byte: upper nibble empty, lower nibble from src */ + out[0] = (in[0] >> 4); + + /* bytes 1.. */ + for (i = 1; i < num_whole_bytes; i++) + out[i] = ((in[i - 1] & 0xF) << 4) | (in[i] >> 4); + + /* shift the last nibble, in case there's an odd count */ + i = num_whole_bytes; + if (num_nibbles & 1) + out[i] = ((in[i - 1] & 0xF) << 4) | (in[i] >> 4); + else + out[i] = (in[i - 1] & 0xF) << 4; +} + +/*! \brief Shift unaligned input to octet-aligned output + * \param[out] out output buffer, octet-aligned + * \param[in] in input buffer, unaligned + * \param[in] num_nibbles number of nibbles + */ +void osmo_nibble_shift_left_unal(uint8_t *out, const uint8_t *in, + unsigned int num_nibbles) +{ + unsigned int i, num_whole_bytes = num_nibbles / 2; + if (!num_whole_bytes) + return; + + for (i = 0; i < num_whole_bytes; i++) + out[i] = ((in[i] & 0xF) << 4) | (in[i + 1] >> 4); + + /* shift the last nibble, in case there's an odd count */ + i = num_whole_bytes; + if (num_nibbles & 1) + out[i] = (in[i] & 0xF) << 4; +} + +/*! \brief convert unpacked bits to soft bits + * \param[out] out output buffer of soft bits + * \param[in] in input buffer of unpacked bits + * \param[in] num_bits number of bits + */ +void osmo_ubit2sbit(sbit_t *out, const ubit_t *in, unsigned int num_bits) +{ + unsigned int i; + for (i = 0; i < num_bits; i++) + out[i] = in[i] ? -127 : 127; +} + +/*! \brief convert soft bits to unpacked bits + * \param[out] out output buffer of unpacked bits + * \param[in] in input buffer of soft bits + * \param[in] num_bits number of bits + */ +void osmo_sbit2ubit(ubit_t *out, const sbit_t *in, unsigned int num_bits) +{ + unsigned int i; + for (i = 0; i < num_bits; i++) + out[i] = in[i] < 0; +} + +/*! \brief convert packed bits to unpacked bits, return length in bytes + * \param[out] out output buffer of unpacked bits + * \param[in] in input buffer of packed bits + * \param[in] num_bits number of bits + * \return number of bytes used in \ref out + */ +int osmo_pbit2ubit(ubit_t *out, const pbit_t *in, unsigned int num_bits) +{ + unsigned int i; + ubit_t *cur = out; + ubit_t *limit = out + num_bits; + + for (i = 0; i < (num_bits/8)+1; i++) { + pbit_t byte = in[i]; + *cur++ = (byte >> 7) & 1; + if (cur >= limit) + break; + *cur++ = (byte >> 6) & 1; + if (cur >= limit) + break; + *cur++ = (byte >> 5) & 1; + if (cur >= limit) + break; + *cur++ = (byte >> 4) & 1; + if (cur >= limit) + break; + *cur++ = (byte >> 3) & 1; + if (cur >= limit) + break; + *cur++ = (byte >> 2) & 1; + if (cur >= limit) + break; + *cur++ = (byte >> 1) & 1; + if (cur >= limit) + break; + *cur++ = (byte >> 0) & 1; + if (cur >= limit) + break; + } + return cur - out; +} + +/*! \brief convert unpacked bits to packed bits (extended options) + * \param[out] out output buffer of packed bits + * \param[in] out_ofs offset into output buffer + * \param[in] in input buffer of unpacked bits + * \param[in] in_ofs offset into input buffer + * \param[in] num_bits number of bits + * \param[in] lsb_mode Encode bits in LSB orde instead of MSB + * \returns length in bytes (max written offset of output buffer + 1) + */ +int osmo_ubit2pbit_ext(pbit_t *out, unsigned int out_ofs, + const ubit_t *in, unsigned int in_ofs, + unsigned int num_bits, int lsb_mode) +{ + int i, op, bn; + for (i=0; i<num_bits; i++) { + op = out_ofs + i; + bn = lsb_mode ? (op&7) : (7-(op&7)); + if (in[in_ofs+i]) + out[op>>3] |= 1 << bn; + else + out[op>>3] &= ~(1 << bn); + } + return ((out_ofs + num_bits - 1) >> 3) + 1; +} + +/*! \brief convert packed bits to unpacked bits (extended options) + * \param[out] out output buffer of unpacked bits + * \param[in] out_ofs offset into output buffer + * \param[in] in input buffer of packed bits + * \param[in] in_ofs offset into input buffer + * \param[in] num_bits number of bits + * \param[in] lsb_mode Encode bits in LSB orde instead of MSB + * \returns length in bytes (max written offset of output buffer + 1) + */ +int osmo_pbit2ubit_ext(ubit_t *out, unsigned int out_ofs, + const pbit_t *in, unsigned int in_ofs, + unsigned int num_bits, int lsb_mode) +{ + int i, ip, bn; + for (i=0; i<num_bits; i++) { + ip = in_ofs + i; + bn = lsb_mode ? (ip&7) : (7-(ip&7)); + out[out_ofs+i] = !!(in[ip>>3] & (1<<bn)); + } + return out_ofs + num_bits; +} + +/*! \brief generalized bit reversal function + * \param[in] x the 32bit value to be reversed + * \param[in] k the type of reversal requested + * \returns the reversed 32bit dword + * + * This function reverses the bit order within a 32bit word. Depending + * on "k", it either reverses all bits in a 32bit dword, or the bytes in + * the dword, or the bits in each byte of a dword, or simply swaps the + * two 16bit words in a dword. See Chapter 7 "Hackers Delight" + */ +uint32_t osmo_bit_reversal(uint32_t x, enum osmo_br_mode k) +{ + if (k & 1) x = (x & 0x55555555) << 1 | (x & 0xAAAAAAAA) >> 1; + if (k & 2) x = (x & 0x33333333) << 2 | (x & 0xCCCCCCCC) >> 2; + if (k & 4) x = (x & 0x0F0F0F0F) << 4 | (x & 0xF0F0F0F0) >> 4; + if (k & 8) x = (x & 0x00FF00FF) << 8 | (x & 0xFF00FF00) >> 8; + if (k & 16) x = (x & 0x0000FFFF) << 16 | (x & 0xFFFF0000) >> 16; + + return x; +} + +/*! \brief reverse the bit-order in each byte of a dword + * \param[in] x 32bit input value + * \returns 32bit value where bits of each byte have been reversed + * + * See Chapter 7 "Hackers Delight" + */ +uint32_t osmo_revbytebits_32(uint32_t x) +{ + x = (x & 0x55555555) << 1 | (x & 0xAAAAAAAA) >> 1; + x = (x & 0x33333333) << 2 | (x & 0xCCCCCCCC) >> 2; + x = (x & 0x0F0F0F0F) << 4 | (x & 0xF0F0F0F0) >> 4; + + return x; +} + +/*! \brief reverse the bit order in a byte + * \param[in] x 8bit input value + * \returns 8bit value where bits order has been reversed + * + * See Chapter 7 "Hackers Delight" + */ +uint32_t osmo_revbytebits_8(uint8_t x) +{ + x = (x & 0x55) << 1 | (x & 0xAA) >> 1; + x = (x & 0x33) << 2 | (x & 0xCC) >> 2; + x = (x & 0x0F) << 4 | (x & 0xF0) >> 4; + + return x; +} + +/*! \brief reverse bit-order of each byte in a buffer + * \param[in] buf buffer containing bytes to be bit-reversed + * \param[in] len length of buffer in bytes + * + * This function reverses the bits in each byte of the buffer + */ +void osmo_revbytebits_buf(uint8_t *buf, int len) +{ + unsigned int i; + unsigned int unaligned_cnt; + int len_remain = len; + + unaligned_cnt = ((unsigned long)buf & 3); + for (i = 0; i < unaligned_cnt; i++) { + buf[i] = osmo_revbytebits_8(buf[i]); + len_remain--; + if (len_remain <= 0) + return; + } + + for (i = unaligned_cnt; i + 3 < len; i += 4) { + osmo_store32be(osmo_revbytebits_32(osmo_load32be(buf + i)), buf + i); + len_remain -= 4; + } + + for (i = len - len_remain; i < len; i++) { + buf[i] = osmo_revbytebits_8(buf[i]); + len_remain--; + } +} + +/*! @} */ diff --git a/firmware/libosmocore/source/msgb.c b/firmware/libosmocore/source/msgb.c new file mode 100644 index 0000000..a27100c --- /dev/null +++ b/firmware/libosmocore/source/msgb.c @@ -0,0 +1,353 @@ +/* (C) 2008 by Harald Welte <laforge@gnumonks.org> + * (C) 2010 by Holger Hans Peter Freyther <zecke@selfish.org> + * All Rights Reserved + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + * + */ + +/*! \addtogroup msgb + * @{ + */ + +/*! \file msgb.c + */ + +#include <unistd.h> +#include <string.h> +#include <stdlib.h> +#include <inttypes.h> + +#include <osmocom/core/msgb.h> +//#include <openbsc/gsm_data.h> +#include <osmocom/core/talloc.h> +//#include <openbsc/debug.h> + +void *tall_msgb_ctx = NULL; + +/*! \brief Allocate a new message buffer + * \param[in] size Length in octets, including headroom + * \param[in] name Human-readable name to be associated with msgb + * \returns dynamically-allocated \ref msgb + * + * This function allocates a 'struct msgb' as well as the underlying + * memory buffer for the actual message data (size specified by \a size) + * using the talloc memory context previously set by \ref msgb_set_talloc_ctx + */ +struct msgb *msgb_alloc(uint16_t size, const char *name) +{ + struct msgb *msg; + + msg = _talloc_zero(tall_msgb_ctx, sizeof(*msg) + size, name); + + if (!msg) { + //LOGP(DRSL, LOGL_FATAL, "unable to allocate msgb\n"); + return NULL; + } + + msg->data_len = size; + msg->len = 0; + msg->data = msg->_data; + msg->head = msg->_data; + msg->tail = msg->_data; + + return msg; +} + +/*! \brief Release given message buffer + * \param[in] m Message buffer to be free'd + */ +void msgb_free(struct msgb *m) +{ + talloc_free(m); +} + +/*! \brief Enqueue message buffer to tail of a queue + * \param[in] queue linked list header of queue + * \param[in] msg message buffer to be added to the queue + * + * The function will append the specified message buffer \a msg to the + * queue implemented by \ref llist_head \a queue + */ +void msgb_enqueue(struct llist_head *queue, struct msgb *msg) +{ + llist_add_tail(&msg->list, queue); +} + +/*! \brief Dequeue message buffer from head of queue + * \param[in] queue linked list header of queue + * \returns message buffer (if any) or NULL if queue empty + * + * The function will remove the first message buffer from the queue + * implemented by \ref llist_head \a queue. + */ +struct msgb *msgb_dequeue(struct llist_head *queue) +{ + struct llist_head *lh; + + if (llist_empty(queue)) + return NULL; + + lh = queue->next; + + if (lh) { + llist_del(lh); + return llist_entry(lh, struct msgb, list); + } else + return NULL; +} + +/*! \brief Re-set all message buffer pointers + * \param[in] msg message buffer that is to be resetted + * + * This will re-set the various internal pointers into the underlying + * message buffer, i.e. remvoe all headroom and treat the msgb as + * completely empty. It also initializes the control buffer to zero. + */ +void msgb_reset(struct msgb *msg) +{ + msg->len = 0; + msg->data = msg->_data; + msg->head = msg->_data; + msg->tail = msg->_data; + + msg->trx = NULL; + msg->lchan = NULL; + msg->l2h = NULL; + msg->l3h = NULL; + msg->l4h = NULL; + + memset(&msg->cb, 0, sizeof(msg->cb)); +} + +/*! \brief get pointer to data section of message buffer + * \param[in] msg message buffer + * \returns pointer to data section of message buffer + */ +uint8_t *msgb_data(const struct msgb *msg) +{ + return msg->data; +} + +/*! \brief get length of message buffer + * \param[in] msg message buffer + * \returns length of data section in message buffer + */ +uint16_t msgb_length(const struct msgb *msg) +{ + return msg->len; +} + +/*! \brief Set the talloc context for \ref msgb_alloc + * Deprecated, use msgb_talloc_ctx_init() instead. + * \param[in] ctx talloc context to be used as root for msgb allocations + */ +void msgb_set_talloc_ctx(void *ctx) +{ + tall_msgb_ctx = ctx; +} + +/*! \brief Initialize a msgb talloc context for \ref msgb_alloc. + * Create a talloc context called "msgb". If \a pool_size is 0, create a named + * const as msgb talloc context. If \a pool_size is nonzero, create a talloc + * pool, possibly for faster msgb allocations (see talloc_pool()). + * \param[in] root_ctx talloc context used as parent for the new "msgb" ctx. + * \param[in] pool_size if nonzero, create a talloc pool of this size. + * \returns the new msgb talloc context, e.g. for reporting + */ +void *msgb_talloc_ctx_init(void *root_ctx, unsigned int pool_size) +{ + if (!pool_size) + tall_msgb_ctx = talloc_size(root_ctx, 0); + else + tall_msgb_ctx = talloc_pool(root_ctx, pool_size); + talloc_set_name_const(tall_msgb_ctx, "msgb"); + return tall_msgb_ctx; +} + +/*! \brief Copy an msgb. + * + * This function allocates a new msgb, copies the data buffer of msg, + * and adjusts the pointers (incl l1h-l4h) accordingly. The cb part + * is not copied. + * \param[in] msg The old msgb object + * \param[in] name Human-readable name to be associated with msgb + */ +struct msgb *msgb_copy(const struct msgb *msg, const char *name) +{ + struct msgb *new_msg; + + new_msg = msgb_alloc(msg->data_len, name); + if (!new_msg) + return NULL; + + /* copy data */ + memcpy(new_msg->_data, msg->_data, new_msg->data_len); + + /* copy header */ + new_msg->len = msg->len; + new_msg->data += msg->data - msg->_data; + new_msg->head += msg->head - msg->_data; + new_msg->tail += msg->tail - msg->_data; + + if (msg->l1h) + new_msg->l1h = new_msg->_data + (msg->l1h - msg->_data); + if (msg->l2h) + new_msg->l2h = new_msg->_data + (msg->l2h - msg->_data); + if (msg->l3h) + new_msg->l3h = new_msg->_data + (msg->l3h - msg->_data); + if (msg->l4h) + new_msg->l4h = new_msg->_data + (msg->l4h - msg->_data); + + return new_msg; +} + +/*! \brief Resize an area within an msgb + * + * This resizes a sub area of the msgb data and adjusts the pointers (incl + * l1h-l4h) accordingly. The cb part is not updated. If the area is extended, + * the contents of the extension is undefined. The complete sub area must be a + * part of [data,tail]. + * + * \param[inout] msg The msgb object + * \param[in] area A pointer to the sub-area + * \param[in] old_size The old size of the sub-area + * \param[in] new_size The new size of the sub-area + * \returns 0 on success, -1 if there is not enough space to extend the area + */ +int msgb_resize_area(struct msgb *msg, uint8_t *area, + int old_size, int new_size) +{ + int rc; + uint8_t *post_start = area + old_size; + int pre_len = area - msg->data; + int post_len = msg->len - old_size - pre_len; + int delta_size = new_size - old_size; + + if (old_size < 0 || new_size < 0) + MSGB_ABORT(msg, "Negative sizes are not allowed\n"); + if (area < msg->data || post_start > msg->tail) + MSGB_ABORT(msg, "Sub area is not fully contained in the msg data\n"); + + if (delta_size == 0) + return 0; + + if (delta_size > 0) { + rc = msgb_trim(msg, msg->len + delta_size); + if (rc < 0) + return rc; + } + + memmove(area + new_size, area + old_size, post_len); + + if (msg->l1h >= post_start) + msg->l1h += delta_size; + if (msg->l2h >= post_start) + msg->l2h += delta_size; + if (msg->l3h >= post_start) + msg->l3h += delta_size; + if (msg->l4h >= post_start) + msg->l4h += delta_size; + + if (delta_size < 0) + msgb_trim(msg, msg->len + delta_size); + + return 0; +} + + +/*! \brief Return a (static) buffer containing a hexdump of the msg + * \param[in] msg message buffer + * \returns a pointer to a static char array + */ +const char *msgb_hexdump(const struct msgb *msg) +{ + static char buf[4100]; + int buf_offs = 0; + int nchars; + const unsigned char *start = msg->data; + const unsigned char *lxhs[4]; + int i; + + lxhs[0] = msg->l1h; + lxhs[1] = msg->l2h; + lxhs[2] = msg->l3h; + lxhs[3] = msg->l4h; + + for (i = 0; i < ARRAY_SIZE(lxhs); i++) { + if (!lxhs[i]) + continue; + + if (lxhs[i] < msg->head) + continue; + if (lxhs[i] > msg->head + msg->data_len) + continue; + if (lxhs[i] > msg->tail) + continue; + if (lxhs[i] < msg->data || lxhs[i] > msg->tail) { + nchars = snprintf(buf + buf_offs, sizeof(buf) - buf_offs, + "(L%d=data%+" PRIdPTR ") ", + i+1, lxhs[i] - msg->data); + buf_offs += nchars; + continue; + } + if (lxhs[i] < start) { + nchars = snprintf(buf + buf_offs, sizeof(buf) - buf_offs, + "(L%d%+" PRIdPTR ") ", i+1, + start - lxhs[i]); + buf_offs += nchars; + continue; + } + nchars = snprintf(buf + buf_offs, sizeof(buf) - buf_offs, + "%s[L%d]> ", + osmo_hexdump(start, lxhs[i] - start), + i+1); + if (nchars < 0 || nchars + buf_offs >= sizeof(buf)) + return "ERROR"; + + buf_offs += nchars; + start = lxhs[i]; + } + nchars = snprintf(buf + buf_offs, sizeof(buf) - buf_offs, + "%s", osmo_hexdump(start, msg->tail - start)); + if (nchars < 0 || nchars + buf_offs >= sizeof(buf)) + return "ERROR"; + + buf_offs += nchars; + + for (i = 0; i < ARRAY_SIZE(lxhs); i++) { + if (!lxhs[i]) + continue; + + if (lxhs[i] < msg->head || lxhs[i] > msg->head + msg->data_len) { + nchars = snprintf(buf + buf_offs, sizeof(buf) - buf_offs, + "(L%d out of range) ", i+1); + } else if (lxhs[i] <= msg->data + msg->data_len && + lxhs[i] > msg->tail) { + nchars = snprintf(buf + buf_offs, sizeof(buf) - buf_offs, + "(L%d=tail%+" PRIdPTR ") ", + i+1, lxhs[i] - msg->tail); + } else + continue; + + if (nchars < 0 || nchars + buf_offs >= sizeof(buf)) + return "ERROR"; + buf_offs += nchars; + } + + return buf; +} + +/*! @} */ diff --git a/firmware/libosmocore/source/panic.c b/firmware/libosmocore/source/panic.c new file mode 100644 index 0000000..9368b70 --- /dev/null +++ b/firmware/libosmocore/source/panic.c @@ -0,0 +1,102 @@ +/* Panic handling */ +/* + * (C) 2010 by Sylvain Munaut <tnt@246tNt.com> + * + * All Rights Reserved + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + * + */ + +/*! \addtogroup utils + * @{ + */ + +/*! \file panic.c + * \brief Routines for panic handling + */ + +#include <assert.h> +#include <osmocom/core/panic.h> +#include <osmocom/core/backtrace.h> + +//#include "../config.h" + + +static osmo_panic_handler_t osmo_panic_handler = (void*)0; + + +#ifndef PANIC_INFLOOP + +#include <stdio.h> +#include <stdlib.h> + +static void osmo_panic_default(const char *fmt, va_list args) +{ + vfprintf(stderr, fmt, args); + osmo_generate_backtrace(); + assert(0); +} + +#else + +static void osmo_panic_default(const char *fmt, va_list args) +{ + while (1); +} + +#endif + + +/*! \brief Terminate the current program with a panic + * + * You can call this function in case some severely unexpected situation + * is detected and the program is supposed to terminate in a way that + * reports the fact that it terminates. + * + * The application can register a panic handler function using \ref + * osmo_set_panic_handler. If it doesn't, a default panic handler + * function is called automatically. + * + * The default function on most systems will generate a backtrace and + * then abort() the process. + */ +void osmo_panic(const char *fmt, ...) +{ + va_list args; + + va_start(args, fmt); + + if (osmo_panic_handler) + osmo_panic_handler(fmt, args); + else + osmo_panic_default(fmt, args); + + va_end(args); +} + + +/*! \brief Set the panic handler + * \param[in] h New panic handler function + * + * This changes the panic handling function from the currently active + * function to a new call-back function supplied by the caller. + */ +void osmo_set_panic_handler(osmo_panic_handler_t h) +{ + osmo_panic_handler = h; +} + +/*! @} */ |