From 879dc971ff61c8405a9bdb505b24ec66296ecb4f Mon Sep 17 00:00:00 2001 From: Harald Welte Date: Sat, 20 Jun 2009 22:36:12 +0200 Subject: fix setfault during registration of VTY TRX function --- openbsc/src/vty_interface.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'openbsc') diff --git a/openbsc/src/vty_interface.c b/openbsc/src/vty_interface.c index a2b3e5620..1b6004631 100644 --- a/openbsc/src/vty_interface.c +++ b/openbsc/src/vty_interface.c @@ -947,7 +947,7 @@ int bsc_vty_init(struct gsm_network *net) install_node(&trx_node, dummy_config_write); install_default(TRX_NODE); install_element(TRX_NODE, &cfg_trx_arfcn_cmd); - install_element(TRX_NODE, &cfg_trx_max_power_red); + install_element(TRX_NODE, &cfg_trx_max_power_red_cmd); install_element(TRX_NODE, &cfg_ts_cmd); install_node(&ts_node, dummy_config_write); -- cgit v1.2.3 From 2cf161be08795be4a074ba2b50fdd81ad1f4c35e Mon Sep 17 00:00:00 2001 From: Harald Welte Date: Sat, 20 Jun 2009 22:36:41 +0200 Subject: introduce talloc all over OpenBSC --- openbsc/include/openbsc/gsm_data.h | 2 + openbsc/include/openbsc/talloc.h | 190 ++++ openbsc/src/Makefile.am | 4 +- openbsc/src/abis_nm.c | 11 +- openbsc/src/bsc_hack.c | 11 +- openbsc/src/e1_config.c | 7 +- openbsc/src/e1_input.c | 9 +- openbsc/src/gsm_04_08.c | 19 +- openbsc/src/gsm_04_11.c | 26 +- openbsc/src/gsm_subscriber.c | 19 +- openbsc/src/input/ipaccess.c | 7 +- openbsc/src/input/misdn.c | 5 +- openbsc/src/mncc.c | 16 +- openbsc/src/msgb.c | 13 +- openbsc/src/paging.c | 10 +- openbsc/src/signal.c | 10 +- openbsc/src/subchan_demux.c | 15 +- openbsc/src/talloc.c | 1796 ++++++++++++++++++++++++++++++++++++ openbsc/src/telnet_interface.c | 8 +- openbsc/src/trau_mux.c | 18 +- 20 files changed, 2149 insertions(+), 47 deletions(-) create mode 100644 openbsc/include/openbsc/talloc.h create mode 100644 openbsc/src/talloc.c (limited to 'openbsc') diff --git a/openbsc/include/openbsc/gsm_data.h b/openbsc/include/openbsc/gsm_data.h index 54ce7e6fd..f300d31bb 100644 --- a/openbsc/include/openbsc/gsm_data.h +++ b/openbsc/include/openbsc/gsm_data.h @@ -407,6 +407,8 @@ struct gsm_bts *gsm_bts_by_lac(struct gsm_network *net, unsigned int lac, char *gsm_band_name(enum gsm_band band); enum gsm_band gsm_band_parse(int mhz); +void *tall_bsc_ctx; + static inline int is_ipaccess_bts(struct gsm_bts *bts) { switch (bts->type) { diff --git a/openbsc/include/openbsc/talloc.h b/openbsc/include/openbsc/talloc.h new file mode 100644 index 000000000..a4b33c3ed --- /dev/null +++ b/openbsc/include/openbsc/talloc.h @@ -0,0 +1,190 @@ +#ifndef _TALLOC_H_ +#define _TALLOC_H_ +/* + Unix SMB/CIFS implementation. + Samba temporary memory allocation functions + + Copyright (C) Andrew Tridgell 2004-2005 + Copyright (C) Stefan Metzmacher 2006 + + ** NOTE! The following LGPL license applies to the talloc + ** library. This does NOT imply that all of Samba is released + ** under the LGPL + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 3 of the License, or (at your option) any later version. + + This library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, see . +*/ + +#include +#include +#include + +/* this is only needed for compatibility with the old talloc */ +typedef void TALLOC_CTX; + +/* + this uses a little trick to allow __LINE__ to be stringified +*/ +#ifndef __location__ +#define __TALLOC_STRING_LINE1__(s) #s +#define __TALLOC_STRING_LINE2__(s) __TALLOC_STRING_LINE1__(s) +#define __TALLOC_STRING_LINE3__ __TALLOC_STRING_LINE2__(__LINE__) +#define __location__ __FILE__ ":" __TALLOC_STRING_LINE3__ +#endif + +#ifndef TALLOC_DEPRECATED +#define TALLOC_DEPRECATED 0 +#endif + +#ifndef PRINTF_ATTRIBUTE +#if (__GNUC__ >= 3) +/** Use gcc attribute to check printf fns. a1 is the 1-based index of + * the parameter containing the format, and a2 the index of the first + * argument. Note that some gcc 2.x versions don't handle this + * properly **/ +#define PRINTF_ATTRIBUTE(a1, a2) __attribute__ ((format (__printf__, a1, a2))) +#else +#define PRINTF_ATTRIBUTE(a1, a2) +#endif +#endif + +/* try to make talloc_set_destructor() and talloc_steal() type safe, + if we have a recent gcc */ +#if (__GNUC__ >= 3) +#define _TALLOC_TYPEOF(ptr) __typeof__(ptr) +#define talloc_set_destructor(ptr, function) \ + do { \ + int (*_talloc_destructor_fn)(_TALLOC_TYPEOF(ptr)) = (function); \ + _talloc_set_destructor((ptr), (int (*)(void *))_talloc_destructor_fn); \ + } while(0) +/* this extremely strange macro is to avoid some braindamaged warning + stupidity in gcc 4.1.x */ +#define talloc_steal(ctx, ptr) ({ _TALLOC_TYPEOF(ptr) __talloc_steal_ret = (_TALLOC_TYPEOF(ptr))_talloc_steal((ctx),(ptr)); __talloc_steal_ret; }) +#else +#define talloc_set_destructor(ptr, function) \ + _talloc_set_destructor((ptr), (int (*)(void *))(function)) +#define _TALLOC_TYPEOF(ptr) void * +#define talloc_steal(ctx, ptr) (_TALLOC_TYPEOF(ptr))_talloc_steal((ctx),(ptr)) +#endif + +#define talloc_reference(ctx, ptr) (_TALLOC_TYPEOF(ptr))_talloc_reference((ctx),(ptr)) +#define talloc_move(ctx, ptr) (_TALLOC_TYPEOF(*(ptr)))_talloc_move((ctx),(void *)(ptr)) + +/* useful macros for creating type checked pointers */ +#define talloc(ctx, type) (type *)talloc_named_const(ctx, sizeof(type), #type) +#define talloc_size(ctx, size) talloc_named_const(ctx, size, __location__) +#define talloc_ptrtype(ctx, ptr) (_TALLOC_TYPEOF(ptr))talloc_size(ctx, sizeof(*(ptr))) + +#define talloc_new(ctx) talloc_named_const(ctx, 0, "talloc_new: " __location__) + +#define talloc_zero(ctx, type) (type *)_talloc_zero(ctx, sizeof(type), #type) +#define talloc_zero_size(ctx, size) _talloc_zero(ctx, size, __location__) + +#define talloc_zero_array(ctx, type, count) (type *)_talloc_zero_array(ctx, sizeof(type), count, #type) +#define talloc_array(ctx, type, count) (type *)_talloc_array(ctx, sizeof(type), count, #type) +#define talloc_array_size(ctx, size, count) _talloc_array(ctx, size, count, __location__) +#define talloc_array_ptrtype(ctx, ptr, count) (_TALLOC_TYPEOF(ptr))talloc_array_size(ctx, sizeof(*(ptr)), count) +#define talloc_array_length(ctx) (talloc_get_size(ctx)/sizeof(*ctx)) + +#define talloc_realloc(ctx, p, type, count) (type *)_talloc_realloc_array(ctx, p, sizeof(type), count, #type) +#define talloc_realloc_size(ctx, ptr, size) _talloc_realloc(ctx, ptr, size, __location__) + +#define talloc_memdup(t, p, size) _talloc_memdup(t, p, size, __location__) + +#define talloc_set_type(ptr, type) talloc_set_name_const(ptr, #type) +#define talloc_get_type(ptr, type) (type *)talloc_check_name(ptr, #type) +#define talloc_get_type_abort(ptr, type) (type *)_talloc_get_type_abort(ptr, #type, __location__) + +#define talloc_find_parent_bytype(ptr, type) (type *)talloc_find_parent_byname(ptr, #type) + +#if TALLOC_DEPRECATED +#define talloc_zero_p(ctx, type) talloc_zero(ctx, type) +#define talloc_p(ctx, type) talloc(ctx, type) +#define talloc_array_p(ctx, type, count) talloc_array(ctx, type, count) +#define talloc_realloc_p(ctx, p, type, count) talloc_realloc(ctx, p, type, count) +#define talloc_destroy(ctx) talloc_free(ctx) +#define talloc_append_string(c, s, a) (s?talloc_strdup_append(s,a):talloc_strdup(c, a)) +#endif + +#define TALLOC_FREE(ctx) do { talloc_free(ctx); ctx=NULL; } while(0) + +/* The following definitions come from talloc.c */ +void *_talloc(const void *context, size_t size); +void *talloc_pool(const void *context, size_t size); +void _talloc_set_destructor(const void *ptr, int (*_destructor)(void *)); +int talloc_increase_ref_count(const void *ptr); +size_t talloc_reference_count(const void *ptr); +void *_talloc_reference(const void *context, const void *ptr); +int talloc_unlink(const void *context, void *ptr); +const char *talloc_set_name(const void *ptr, const char *fmt, ...) PRINTF_ATTRIBUTE(2,3); +void talloc_set_name_const(const void *ptr, const char *name); +void *talloc_named(const void *context, size_t size, + const char *fmt, ...) PRINTF_ATTRIBUTE(3,4); +void *talloc_named_const(const void *context, size_t size, const char *name); +const char *talloc_get_name(const void *ptr); +void *talloc_check_name(const void *ptr, const char *name); +void *_talloc_get_type_abort(const void *ptr, const char *name, const char *location); +void *talloc_parent(const void *ptr); +const char *talloc_parent_name(const void *ptr); +void *talloc_init(const char *fmt, ...) PRINTF_ATTRIBUTE(1,2); +int talloc_free(void *ptr); +void talloc_free_children(void *ptr); +void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *name); +void *_talloc_steal(const void *new_ctx, const void *ptr); +void *_talloc_move(const void *new_ctx, const void *pptr); +size_t talloc_total_size(const void *ptr); +size_t talloc_total_blocks(const void *ptr); +void talloc_report_depth_cb(const void *ptr, int depth, int max_depth, + void (*callback)(const void *ptr, + int depth, int max_depth, + int is_ref, + void *private_data), + void *private_data); +void talloc_report_depth_file(const void *ptr, int depth, int max_depth, FILE *f); +void talloc_report_full(const void *ptr, FILE *f); +void talloc_report(const void *ptr, FILE *f); +void talloc_enable_null_tracking(void); +void talloc_disable_null_tracking(void); +void talloc_enable_leak_report(void); +void talloc_enable_leak_report_full(void); +void *_talloc_zero(const void *ctx, size_t size, const char *name); +void *_talloc_memdup(const void *t, const void *p, size_t size, const char *name); +void *_talloc_array(const void *ctx, size_t el_size, unsigned count, const char *name); +void *_talloc_zero_array(const void *ctx, size_t el_size, unsigned count, const char *name); +void *_talloc_realloc_array(const void *ctx, void *ptr, size_t el_size, unsigned count, const char *name); +void *talloc_realloc_fn(const void *context, void *ptr, size_t size); +void *talloc_autofree_context(void); +size_t talloc_get_size(const void *ctx); +void *talloc_find_parent_byname(const void *ctx, const char *name); +void talloc_show_parents(const void *context, FILE *file); +int talloc_is_parent(const void *context, const void *ptr); + +char *talloc_strdup(const void *t, const char *p); +char *talloc_strdup_append(char *s, const char *a); +char *talloc_strdup_append_buffer(char *s, const char *a); + +char *talloc_strndup(const void *t, const char *p, size_t n); +char *talloc_strndup_append(char *s, const char *a, size_t n); +char *talloc_strndup_append_buffer(char *s, const char *a, size_t n); + +char *talloc_vasprintf(const void *t, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0); +char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0); +char *talloc_vasprintf_append_buffer(char *s, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0); + +char *talloc_asprintf(const void *t, const char *fmt, ...) PRINTF_ATTRIBUTE(2,3); +char *talloc_asprintf_append(char *s, const char *fmt, ...) PRINTF_ATTRIBUTE(2,3); +char *talloc_asprintf_append_buffer(char *s, const char *fmt, ...) PRINTF_ATTRIBUTE(2,3); + +void talloc_set_abort_fn(void (*abort_fn)(const char *reason)); + +#endif diff --git a/openbsc/src/Makefile.am b/openbsc/src/Makefile.am index f4b8e552d..c0ac63cb1 100644 --- a/openbsc/src/Makefile.am +++ b/openbsc/src/Makefile.am @@ -9,7 +9,7 @@ libbsc_a_SOURCES = abis_rsl.c abis_nm.c gsm_04_08.c gsm_data.c mncc.c \ gsm_subscriber.c msgb.c select.c chan_alloc.c timer.c debug.c db.c \ gsm_04_11.c telnet_interface.c subchan_demux.c \ trau_frame.c trau_mux.c paging.c e1_config.c e1_input.c tlv_parser.c \ - input/misdn.c input/ipaccess.c signal.c gsm_utils.c + input/misdn.c input/ipaccess.c signal.c gsm_utils.c talloc.c libvty_a_SOURCES = vty/buffer.c vty/command.c vty/vector.c vty/vty.c @@ -17,7 +17,7 @@ bsc_hack_SOURCES = bsc_hack.c vty_interface.c bsc_hack_LDADD = libbsc.a libvty.a -ldl -ldbi $(LIBCRYPT) bs11_config_SOURCES = bs11_config.c abis_nm.c gsm_data.c msgb.c debug.c \ - select.c timer.c rs232.c tlv_parser.c signal.c + select.c timer.c rs232.c tlv_parser.c signal.c talloc.c ipaccess_find_SOURCES = ipaccess-find.c select.c timer.c diff --git a/openbsc/src/abis_nm.c b/openbsc/src/abis_nm.c index 905289b6d..bd3ba19e1 100644 --- a/openbsc/src/abis_nm.c +++ b/openbsc/src/abis_nm.c @@ -43,6 +43,7 @@ #include #include #include +#include #define OM_ALLOC_SIZE 1024 #define OM_HEADROOM_SIZE 128 @@ -2008,6 +2009,8 @@ int abis_nm_bs11_get_state(struct gsm_bts *bts) /* BS11 SWL */ +static void *tall_fle_ctx; + struct abis_nm_bs11_sw { struct gsm_bts *bts; char swl_fname[PATH_MAX]; @@ -2043,6 +2046,10 @@ static int bs11_read_swl_file(struct abis_nm_bs11_sw *bs11_sw) FILE *swl; int rc = 0; + if (!tall_fle_ctx) + tall_fle_ctx = talloc_named_const(tall_bsc_ctx, 1, + "bs11_file_list_entry"); + swl = fopen(bs11_sw->swl_fname, "r"); if (!swl) return -ENODEV; @@ -2050,7 +2057,7 @@ static int bs11_read_swl_file(struct abis_nm_bs11_sw *bs11_sw) /* zero the stale file list, if any */ llist_for_each_safe(lh, lh2, &bs11_sw->file_list) { llist_del(lh); - free(lh); + talloc_free(lh); } while (fgets(linebuf, sizeof(linebuf), swl)) { @@ -2071,7 +2078,7 @@ static int bs11_read_swl_file(struct abis_nm_bs11_sw *bs11_sw) if (rc < 2) continue; - fle = malloc(sizeof(*fle)); + fle = talloc(tall_fle_ctx, struct file_list_entry); if (!fle) { rc = -ENOMEM; goto out; diff --git a/openbsc/src/bsc_hack.c b/openbsc/src/bsc_hack.c index 43f1011c7..ae67ade31 100644 --- a/openbsc/src/bsc_hack.c +++ b/openbsc/src/bsc_hack.c @@ -47,6 +47,9 @@ #include #include #include +#include + +void *tall_bsc_ctx; /* global pointer to the gsm network data structure */ static struct gsm_network *gsmnet; @@ -1078,7 +1081,7 @@ static void print_help() static void handle_options(int argc, char** argv) { while (1) { - int tmp, option_index = 0, c; + int option_index = 0, c; static struct option long_options[] = { {"help", 0, 0, 'h'}, {"debug", 1, 0, 'd'}, @@ -1170,6 +1173,9 @@ static void signal_handler(int signal) case SIGABRT: shutdown_net(gsmnet); break; + case SIGUSR1: + talloc_report_full(tall_bsc_ctx, stderr); + break; default: break; } @@ -1179,6 +1185,8 @@ int main(int argc, char **argv) { int rc; + tall_bsc_ctx = talloc_named_const(NULL, 1, "openbsc"); + /* parse options */ handle_options(argc, argv); @@ -1191,6 +1199,7 @@ int main(int argc, char **argv) signal(SIGHUP, &signal_handler); signal(SIGABRT, &signal_handler); + signal(SIGUSR1, &signal_handler); while (1) { bsc_upqueue(gsmnet); diff --git a/openbsc/src/e1_config.c b/openbsc/src/e1_config.c index fc23b55e1..abc30402f 100644 --- a/openbsc/src/e1_config.c +++ b/openbsc/src/e1_config.c @@ -8,6 +8,7 @@ #include #include #include +#include #define SAPI_L2ML 0 #define SAPI_OML 62 @@ -24,7 +25,7 @@ int e1_config(struct gsm_bts *bts, int cardnr, int release_l2) struct e1inp_ts *sign_ts; struct e1inp_sign_link *oml_link, *rsl_link; - line = malloc(sizeof(*line)); + line = talloc(tall_bsc_ctx, struct e1inp_line); if (!line) return -ENOMEM; memset(line, 0, sizeof(*line)); @@ -79,9 +80,9 @@ int ia_config_connect(struct gsm_bts *bts, struct sockaddr_in *sin) struct e1inp_ts *sign_ts, *rsl_ts; struct e1inp_sign_link *oml_link, *rsl_link; - line = malloc(sizeof(*line)); + line = talloc(tall_bsc_ctx, struct e1inp_line); if (!line) - return NULL; + return -ENOMEM; memset(line, 0, sizeof(*line)); /* create E1 timeslots for signalling and TRAU frames */ diff --git a/openbsc/src/e1_input.c b/openbsc/src/e1_input.c index 034bd9723..84dde9047 100644 --- a/openbsc/src/e1_input.c +++ b/openbsc/src/e1_input.c @@ -51,6 +51,7 @@ #include #include #include +#include #define NUM_E1_TS 32 @@ -60,6 +61,8 @@ LLIST_HEAD(e1inp_driver_list); /* list of all E1 lines */ LLIST_HEAD(e1inp_line_list); +static void *tall_sigl_ctx; + /* to be implemented, e.g. by bsc_hack.c */ void input_event(int event, enum e1inp_sign_type type, struct gsm_bts_trx *trx); @@ -366,7 +369,11 @@ e1inp_sign_link_create(struct e1inp_ts *ts, enum e1inp_sign_type type, if (ts->type != E1INP_TS_TYPE_SIGN) return NULL; - link = malloc(sizeof(*link)); + if (!tall_sigl_ctx) + tall_sigl_ctx = talloc_named_const(tall_bsc_ctx, 1, + "e1inp_sign_link"); + + link = talloc(tall_sigl_ctx, struct e1inp_sign_link); if (!link) return NULL; diff --git a/openbsc/src/gsm_04_08.c b/openbsc/src/gsm_04_08.c index 117fb1224..49234f8d8 100644 --- a/openbsc/src/gsm_04_08.c +++ b/openbsc/src/gsm_04_08.c @@ -44,6 +44,7 @@ #include #include #include +#include #define GSM48_ALLOC_SIZE 1024 #define GSM48_ALLOC_HEADROOM 128 @@ -52,6 +53,9 @@ #define GSM_MAX_SSVERSION 128 #define GSM_MAX_USERUSER 128 +static void *tall_locop_ctx; +static void *tall_trans_ctx; + static const struct tlv_definition rsl_att_tlvdef = { .def = { [GSM48_IE_MOBILE_ID] = { TLV_TYPE_TLV }, @@ -337,7 +341,7 @@ static void release_loc_updating_req(struct gsm_lchan *lchan) return; bsc_del_timer(&lchan->loc_operation->updating_timer); - free(lchan->loc_operation); + talloc_free(lchan->loc_operation); lchan->loc_operation = 0; put_lchan(lchan); } @@ -347,8 +351,11 @@ static void allocate_loc_updating_req(struct gsm_lchan *lchan) use_lchan(lchan); release_loc_updating_req(lchan); - lchan->loc_operation = (struct gsm_loc_updating_operation *) - malloc(sizeof(*lchan->loc_operation)); + if (!tall_locop_ctx) + tall_locop_ctx = talloc_named_const(tall_bsc_ctx, 1, + "loc_updating_oper"); + lchan->loc_operation = talloc(tall_locop_ctx, + struct gsm_loc_updating_operation); memset(lchan->loc_operation, 0, sizeof(*lchan->loc_operation)); } @@ -1911,7 +1918,7 @@ void free_trans(struct gsm_trans *trans) llist_del(&trans->entry); - free(trans); + talloc_free(trans); } static int gsm48_cc_tx_setup(struct gsm_trans *trans, void *arg); @@ -3420,7 +3427,7 @@ int mncc_send(struct gsm_network *net, int msg_type, void *arg) GSM48_CC_CAUSE_DEST_OOO); } /* Create transaction */ - if (!(trans = calloc(1, sizeof(struct gsm_trans)))) { + if (!(trans = talloc(tall_trans_ctx, struct gsm_trans))) { DEBUGP(DCC, "No memory for trans.\n"); subscr_put(subscr); /* Ressource unavailable */ @@ -3626,7 +3633,7 @@ static int gsm0408_rcv_cc(struct msgb *msg) DEBUGP(DCC, "Unknown transaction ID %02x, " "creating new trans.\n", transaction_id); /* Create transaction */ - if (!(trans = calloc(1, sizeof(struct gsm_trans)))) { + if (!(trans = talloc(tall_trans_ctx, struct gsm_trans))) { DEBUGP(DCC, "No memory for trans.\n"); rc = gsm48_tx_simple(msg->lchan, GSM48_PDISC_CC | transaction_id, diff --git a/openbsc/src/gsm_04_11.c b/openbsc/src/gsm_04_11.c index 3d5820d66..571da4cba 100644 --- a/openbsc/src/gsm_04_11.c +++ b/openbsc/src/gsm_04_11.c @@ -41,10 +41,14 @@ #include #include #include +#include #define GSM411_ALLOC_SIZE 1024 #define GSM411_ALLOC_HEADROOM 128 +static void *tall_sms_ctx; +static void *tall_gsms_ctx; + struct msgb *gsm411_msgb_alloc(void) { return msgb_alloc_headroom(GSM411_ALLOC_SIZE, GSM411_ALLOC_HEADROOM); @@ -139,8 +143,8 @@ static int gsm340_rx_sms_submit(struct msgb *msg, struct sms_submit *sms, { if (db_sms_store(gsms) != 0) { DEBUGP(DSMS, "Failed to store SMS in Database\n"); - free(sms); - free(gsms); + talloc_free(sms); + talloc_free(gsms); return -EIO; } return 0; @@ -156,14 +160,22 @@ static int gsm340_rx_tpdu(struct msgb *msg) u_int8_t address_lv[12]; /* according to 03.40 / 9.1.2.5 */ int rc = 0; - sms = malloc(sizeof(*sms)); + if (!tall_sms_ctx) + tall_sms_ctx = talloc_named_const(tall_bsc_ctx, 1, + "sms_submit"); + + sms = talloc(tall_sms_ctx, struct sms_submit); if (!sms) return -ENOMEM; memset(sms, 0, sizeof(*sms)); - gsms = malloc(sizeof(*gsms)); + if (!tall_gsms_ctx) + tall_gsms_ctx = talloc_named_const(tall_bsc_ctx, 1, + "sms"); + + gsms = talloc(tall_gsms_ctx, struct gsm_sms); if (!gsms) { - free(sms); + talloc_free(sms); return -ENOMEM; } memset(gsms, 0, sizeof(*gsms)); @@ -268,8 +280,8 @@ static int gsm340_rx_tpdu(struct msgb *msg) } out: - free(gsms); - free(sms); + talloc_free(gsms); + talloc_free(sms); return rc; } diff --git a/openbsc/src/gsm_subscriber.c b/openbsc/src/gsm_subscriber.c index 3062a6bef..a323d4e87 100644 --- a/openbsc/src/gsm_subscriber.c +++ b/openbsc/src/gsm_subscriber.c @@ -27,6 +27,7 @@ #include #include +#include #include #include #include @@ -34,6 +35,8 @@ #include LLIST_HEAD(active_subscribers); +static void *tall_subscr_ctx; +static void *tall_sub_req_ctx; /* * Struct for pending channel requests. This is managed in the @@ -82,7 +85,7 @@ static int subscr_paging_cb(unsigned int hooknum, unsigned int event, request->cbfn(hooknum, event, msg, data, request->param); subscr->in_callback = 0; - free(request); + talloc_free(request); return 0; } @@ -100,7 +103,11 @@ struct gsm_subscriber *subscr_alloc(void) { struct gsm_subscriber *s; - s = malloc(sizeof(struct gsm_subscriber)); + if (!tall_subscr_ctx) + tall_subscr_ctx = talloc_named_const(tall_bsc_ctx, 1, + "subscriber"); + + s = talloc(tall_subscr_ctx, struct gsm_subscriber); if (!s) return NULL; @@ -116,7 +123,7 @@ struct gsm_subscriber *subscr_alloc(void) static void subscr_free(struct gsm_subscriber *subscr) { llist_del(&subscr->entry); - free(subscr); + talloc_free(subscr); } struct gsm_subscriber *subscr_get_by_tmsi(const char *tmsi) @@ -202,7 +209,11 @@ void subscr_get_channel(struct gsm_subscriber *subscr, { struct subscr_request *request; - request = (struct subscr_request *)malloc(sizeof(*request)); + if (!tall_sub_req_ctx) + tall_sub_req_ctx = talloc_named_const(tall_bsc_ctx, 1, + "subscr_request"); + + request = talloc(tall_sub_req_ctx, struct subscr_request); if (!request) { if (cbfn) cbfn(GSM_HOOK_RR_PAGING, GSM_PAGING_OOM, diff --git a/openbsc/src/input/ipaccess.c b/openbsc/src/input/ipaccess.c index ea7f847c2..ccc178d17 100644 --- a/openbsc/src/input/ipaccess.c +++ b/openbsc/src/input/ipaccess.c @@ -42,6 +42,7 @@ #include #include #include +#include /* data structure for one E1 interface with A-bis */ struct ia_e1_handle { @@ -429,7 +430,7 @@ static int listen_fd_cb(struct bsc_fd *listen_bfd, unsigned int what) } DEBUGP(DINP, "accept()ed new OML link from %s\n", inet_ntoa(sa.sin_addr)); - line = malloc(sizeof(*line)); + line = talloc(tall_bsc_ctx, struct e1inp_line); if (!line) { close(ret); return -ENOMEM; @@ -467,7 +468,7 @@ static int rsl_listen_fd_cb(struct bsc_fd *listen_bfd, unsigned int what) { struct sockaddr_in sa; socklen_t sa_len = sizeof(sa); - struct bsc_fd *bfd = malloc(sizeof(*bfd)); + struct bsc_fd *bfd = talloc(tall_bsc_ctx, struct bsc_fd); int ret; if (!(what & BSC_FD_READ)) @@ -581,7 +582,7 @@ int ipaccess_setup(struct gsm_network *gsmnet) if (ret) return ret; - e1h = malloc(sizeof(*e1h)); + e1h = talloc(tall_bsc_ctx, struct ia_e1_handle); memset(e1h, 0, sizeof(*e1h)); e1h->gsmnet = gsmnet; diff --git a/openbsc/src/input/misdn.c b/openbsc/src/input/misdn.c index de8d41f21..44f09646d 100644 --- a/openbsc/src/input/misdn.c +++ b/openbsc/src/input/misdn.c @@ -47,6 +47,7 @@ #include #include #include +#include /* data structure for one E1 interface with A-bis */ struct mi_e1_handle { @@ -136,7 +137,7 @@ static int handle_ts1_read(struct bsc_fd *bfd) link = e1inp_lookup_sign_link(e1i_ts, l2addr.tei, l2addr.sapi); if (!link) { DEBUGPC(DMI, "mISDN message for unknown sign_link\n"); - free(msg); + msgb_free(msg); return -EINVAL; } /* save the channel number in the driver private struct */ @@ -483,7 +484,7 @@ int mi_setup(int cardnr, struct e1inp_line *line, int release_l2) /* create the actual line instance */ /* FIXME: do this independent of driver registration */ - e1h = malloc(sizeof(*e1h)); + e1h = talloc(tall_bsc_ctx, struct mi_e1_handle); memset(e1h, 0, sizeof(*e1h)); e1h->cardnr = cardnr; diff --git a/openbsc/src/mncc.c b/openbsc/src/mncc.c index 4282aaf3c..71f2ad501 100644 --- a/openbsc/src/mncc.c +++ b/openbsc/src/mncc.c @@ -27,6 +27,10 @@ #include #include #include +#include +#include + +static void *tall_call_ctx; static struct mncc_names { char *name; @@ -103,7 +107,7 @@ static void free_call(struct gsm_call *call) { llist_del(&call->entry); DEBUGP(DMNCC, "(call %x) Call removed.\n", call->callref); - free(call); + talloc_free(call); } @@ -136,8 +140,11 @@ static int mncc_setup_ind(struct gsm_call *call, int msg_type, if (call->remote_ref) return 0; + if (!tall_call_ctx) + tall_call_ctx = talloc_named_const(tall_bsc_ctx, 1, + "gsm_call"); /* create remote call */ - if (!(remote = calloc(1, sizeof(struct gsm_call)))) { + if (!(remote = talloc(tall_call_ctx, struct gsm_call))) { memset(&mncc, 0, sizeof(struct gsm_mncc)); mncc.callref = call->callref; mncc_set_cause(&mncc, GSM48_CAUSE_LOC_PRN_S_LU, @@ -299,8 +306,11 @@ int mncc_recv(struct gsm_network *net, int msg_type, void *arg) if (!call) { if (msg_type != MNCC_SETUP_IND) return 0; /* drop */ + if (!tall_call_ctx) + tall_call_ctx = talloc_named_const(tall_bsc_ctx, 1, + "gsm_call"); /* create call */ - if (!(call = calloc(1, sizeof(struct gsm_call)))) { + if (!(call = talloc(tall_call_ctx, struct gsm_call))) { struct gsm_mncc rel; memset(&rel, 0, sizeof(struct gsm_mncc)); diff --git a/openbsc/src/msgb.c b/openbsc/src/msgb.c index ce390e84a..8bdc9aa70 100644 --- a/openbsc/src/msgb.c +++ b/openbsc/src/msgb.c @@ -24,10 +24,19 @@ #include #include +#include +#include + +static void *tall_msgb_ctx; struct msgb *msgb_alloc(u_int16_t size) { - struct msgb *msg = malloc(sizeof(*msg) + size); + struct msgb *msg; + + if (!tall_msgb_ctx) + tall_msgb_ctx = talloc_named_const(tall_bsc_ctx, 1, "msgb"); + + msg = talloc_size(tall_msgb_ctx, sizeof(*msg) + size); if (!msg) return NULL; @@ -48,7 +57,7 @@ struct msgb *msgb_alloc(u_int16_t size) void msgb_free(struct msgb *m) { - free(m); + talloc_free(m); } void msgb_enqueue(struct llist_head *queue, struct msgb *msg) diff --git a/openbsc/src/paging.c b/openbsc/src/paging.c index 53e51464a..217da7e0a 100644 --- a/openbsc/src/paging.c +++ b/openbsc/src/paging.c @@ -40,6 +40,7 @@ #include #include +#include #include #include #include @@ -48,6 +49,8 @@ #define PAGING_TIMEOUT 1, 75000 #define MAX_PAGING_REQUEST 750 +static void *tall_paging_ctx; + static unsigned int calculate_group(struct gsm_bts *bts, struct gsm_subscriber *subscr) { int ccch_conf; @@ -81,7 +84,7 @@ static void paging_remove_request(struct gsm_bts_paging_state *paging_bts, bsc_del_timer(&to_be_deleted->T3113); llist_del(&to_be_deleted->entry); subscr_put(to_be_deleted->subscr); - free(to_be_deleted); + talloc_free(to_be_deleted); } static void page_ms(struct gsm_paging_request *request) @@ -216,13 +219,16 @@ static void _paging_request(struct gsm_bts *bts, struct gsm_subscriber *subscr, struct gsm_bts_paging_state *bts_entry = &bts->paging; struct gsm_paging_request *req; + if (!tall_paging_ctx) + tall_paging_ctx = talloc_named_const(NULL, 1, "paging_request"); + if (paging_pending_request(bts_entry, subscr)) { DEBUGP(DPAG, "Paging request already pending\n"); return; } DEBUGP(DPAG, "Start paging on bts %d.\n", bts->nr); - req = (struct gsm_paging_request *)malloc(sizeof(*req)); + req = talloc(tall_paging_ctx, struct gsm_paging_request); memset(req, 0, sizeof(*req)); req->subscr = subscr_get(subscr); req->bts = bts; diff --git a/openbsc/src/signal.c b/openbsc/src/signal.c index 4227c6dc1..41352fb1a 100644 --- a/openbsc/src/signal.c +++ b/openbsc/src/signal.c @@ -19,10 +19,12 @@ */ #include +#include #include #include +static void *tall_sigh_ctx; static LLIST_HEAD(signal_handler_list); struct signal_handler { @@ -35,8 +37,12 @@ struct signal_handler { int register_signal_handler(unsigned int subsys, signal_cbfn *cbfn, void *data) { - struct signal_handler *sig_data = malloc(sizeof(*sig_data)); + struct signal_handler *sig_data; + if (!tall_sigh_ctx) + tall_sigh_ctx = talloc_named_const(NULL, 1, "signal_handler"); + + sig_data = talloc(tall_sigh_ctx, struct signal_handler); if (!sig_data) return -ENOMEM; @@ -61,7 +67,7 @@ void unregister_signal_handler(unsigned int subsys, signal_cbfn *cbfn, void *dat if (handler->cbfn == cbfn && handler->data == data && subsys == handler->subsys) { llist_del(&handler->entry); - free(handler); + talloc_free(handler); break; } } diff --git a/openbsc/src/subchan_demux.c b/openbsc/src/subchan_demux.c index c662bcd0e..56f3dd3f2 100644 --- a/openbsc/src/subchan_demux.c +++ b/openbsc/src/subchan_demux.c @@ -28,6 +28,10 @@ #include #include #include +#include +#include + +static void *tall_tqe_ctx; static inline void append_bit(struct demux_subch *sch, u_int8_t bit) { @@ -201,7 +205,7 @@ static int get_subch_bits(struct subch_mux *mx, int subch, /* free the tx_queue entry if it is fully consumed */ if (txe->next_bit >= txe->bit_len) { llist_del(&txe->list); - free(txe); + talloc_free(txe); } /* increment global number of bits dequeued */ @@ -277,7 +281,7 @@ static void tx_queue_evict(struct mux_subch *sch, int num_evict) tqe = llist_entry(sch->tx_queue.next, struct subch_txq_entry, list); llist_del(&tqe->list); - free(tqe); + talloc_free(tqe); } } @@ -286,9 +290,9 @@ int subchan_mux_enqueue(struct subch_mux *mx, int s_nr, const u_int8_t *data, int len) { struct mux_subch *sch = &mx->subch[s_nr]; - struct subch_txq_entry *tqe = malloc(sizeof(*tqe) + len); int list_len = llist_len(&sch->tx_queue); - + struct subch_txq_entry *tqe = talloc_size(tall_tqe_ctx, + sizeof(*tqe) + len); if (!tqe) return -ENOMEM; @@ -309,6 +313,9 @@ int subchan_mux_init(struct subch_mux *mx) { int i; + if (!tall_tqe_ctx) + tall_tqe_ctx = talloc_named_const(tall_bsc_ctx, 1, + "subch_txq_entry"); memset(mx, 0, sizeof(*mx)); for (i = 0; i < NR_SUBCH; i++) { struct mux_subch *sch = &mx->subch[i]; diff --git a/openbsc/src/talloc.c b/openbsc/src/talloc.c new file mode 100644 index 000000000..bd5e1b0e0 --- /dev/null +++ b/openbsc/src/talloc.c @@ -0,0 +1,1796 @@ +/* + Samba Unix SMB/CIFS implementation. + + Samba trivial allocation library - new interface + + NOTE: Please read talloc_guide.txt for full documentation + + Copyright (C) Andrew Tridgell 2004 + Copyright (C) Stefan Metzmacher 2006 + + ** NOTE! The following LGPL license applies to the talloc + ** library. This does NOT imply that all of Samba is released + ** under the LGPL + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 3 of the License, or (at your option) any later version. + + This library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, see . +*/ + +/* + inspired by http://swapped.cc/halloc/ +*/ + +#ifdef _SAMBA_BUILD_ +#include "version.h" +#if (SAMBA_VERSION_MAJOR<4) +#include "includes.h" +/* This is to circumvent SAMBA3's paranoid malloc checker. Here in this file + * we trust ourselves... */ +#ifdef malloc +#undef malloc +#endif +#ifdef realloc +#undef realloc +#endif +#define _TALLOC_SAMBA3 +#endif /* (SAMBA_VERSION_MAJOR<4) */ +#endif /* _SAMBA_BUILD_ */ + +#ifndef _TALLOC_SAMBA3 +//#include "replace.h" +#include +#include +#include +#include +#define __USE_GNU +#include +#undef __USE_GNU +#include +#define MIN(x,y) ((x) < (y) ? (x) : (y)) +#endif /* not _TALLOC_SAMBA3 */ + +/* use this to force every realloc to change the pointer, to stress test + code that might not cope */ +#define ALWAYS_REALLOC 0 + + +#define MAX_TALLOC_SIZE 0x10000000 +#define TALLOC_MAGIC 0xe814ec70 +#define TALLOC_FLAG_FREE 0x01 +#define TALLOC_FLAG_LOOP 0x02 +#define TALLOC_FLAG_POOL 0x04 /* This is a talloc pool */ +#define TALLOC_FLAG_POOLMEM 0x08 /* This is allocated in a pool */ +#define TALLOC_MAGIC_REFERENCE ((const char *)1) + +/* by default we abort when given a bad pointer (such as when talloc_free() is called + on a pointer that came from malloc() */ +#ifndef TALLOC_ABORT +#define TALLOC_ABORT(reason) abort() +#endif + +#ifndef discard_const_p +#if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T) +# define discard_const_p(type, ptr) ((type *)((intptr_t)(ptr))) +#else +# define discard_const_p(type, ptr) ((type *)(ptr)) +#endif +#endif + +/* these macros gain us a few percent of speed on gcc */ +#if (__GNUC__ >= 3) +/* the strange !! is to ensure that __builtin_expect() takes either 0 or 1 + as its first argument */ +#ifndef likely +#define likely(x) __builtin_expect(!!(x), 1) +#endif +#ifndef unlikely +#define unlikely(x) __builtin_expect(!!(x), 0) +#endif +#else +#ifndef likely +#define likely(x) (x) +#endif +#ifndef unlikely +#define unlikely(x) (x) +#endif +#endif + +/* this null_context is only used if talloc_enable_leak_report() or + talloc_enable_leak_report_full() is called, otherwise it remains + NULL +*/ +static void *null_context; +static void *autofree_context; + +struct talloc_reference_handle { + struct talloc_reference_handle *next, *prev; + void *ptr; +}; + +typedef int (*talloc_destructor_t)(void *); + +struct talloc_chunk { + struct talloc_chunk *next, *prev; + struct talloc_chunk *parent, *child; + struct talloc_reference_handle *refs; + talloc_destructor_t destructor; + const char *name; + size_t size; + unsigned flags; + + /* + * "pool" has dual use: + * + * For the talloc pool itself (i.e. TALLOC_FLAG_POOL is set), "pool" + * marks the end of the currently allocated area. + * + * For members of the pool (i.e. TALLOC_FLAG_POOLMEM is set), "pool" + * is a pointer to the struct talloc_chunk of the pool that it was + * allocated from. This way children can quickly find the pool to chew + * from. + */ + void *pool; +}; + +/* 16 byte alignment seems to keep everyone happy */ +#define TC_HDR_SIZE ((sizeof(struct talloc_chunk)+15)&~15) +#define TC_PTR_FROM_CHUNK(tc) ((void *)(TC_HDR_SIZE + (char*)tc)) + +static void (*talloc_abort_fn)(const char *reason); + +void talloc_set_abort_fn(void (*abort_fn)(const char *reason)) +{ + talloc_abort_fn = abort_fn; +} + +static void talloc_abort(const char *reason) +{ + if (!talloc_abort_fn) { + TALLOC_ABORT(reason); + } + + talloc_abort_fn(reason); +} + +static void talloc_abort_double_free(void) +{ + talloc_abort("Bad talloc magic value - double free"); +} + +static void talloc_abort_unknown_value(void) +{ + talloc_abort("Bad talloc magic value - unknown value"); +} + +/* panic if we get a bad magic value */ +static inline struct talloc_chunk *talloc_chunk_from_ptr(const void *ptr) +{ + const char *pp = (const char *)ptr; + struct talloc_chunk *tc = discard_const_p(struct talloc_chunk, pp - TC_HDR_SIZE); + if (unlikely((tc->flags & (TALLOC_FLAG_FREE | ~0xF)) != TALLOC_MAGIC)) { + if (tc->flags & TALLOC_FLAG_FREE) { + talloc_abort_double_free(); + } else { + talloc_abort_unknown_value(); + } + } + return tc; +} + +/* hook into the front of the list */ +#define _TLIST_ADD(list, p) \ +do { \ + if (!(list)) { \ + (list) = (p); \ + (p)->next = (p)->prev = NULL; \ + } else { \ + (list)->prev = (p); \ + (p)->next = (list); \ + (p)->prev = NULL; \ + (list) = (p); \ + }\ +} while (0) + +/* remove an element from a list - element doesn't have to be in list. */ +#define _TLIST_REMOVE(list, p) \ +do { \ + if ((p) == (list)) { \ + (list) = (p)->next; \ + if (list) (list)->prev = NULL; \ + } else { \ + if ((p)->prev) (p)->prev->next = (p)->next; \ + if ((p)->next) (p)->next->prev = (p)->prev; \ + } \ + if ((p) && ((p) != (list))) (p)->next = (p)->prev = NULL; \ +} while (0) + + +/* + return the parent chunk of a pointer +*/ +static inline struct talloc_chunk *talloc_parent_chunk(const void *ptr) +{ + struct talloc_chunk *tc; + + if (unlikely(ptr == NULL)) { + return NULL; + } + + tc = talloc_chunk_from_ptr(ptr); + while (tc->prev) tc=tc->prev; + + return tc->parent; +} + +void *talloc_parent(const void *ptr) +{ + struct talloc_chunk *tc = talloc_parent_chunk(ptr); + return tc? TC_PTR_FROM_CHUNK(tc) : NULL; +} + +/* + find parents name +*/ +const char *talloc_parent_name(const void *ptr) +{ + struct talloc_chunk *tc = talloc_parent_chunk(ptr); + return tc? tc->name : NULL; +} + +/* + A pool carries an in-pool object count count in the first 16 bytes. + bytes. This is done to support talloc_steal() to a parent outside of the + pool. The count includes the pool itself, so a talloc_free() on a pool will + only destroy the pool if the count has dropped to zero. A talloc_free() of a + pool member will reduce the count, and eventually also call free(3) on the + pool memory. + + The object count is not put into "struct talloc_chunk" because it is only + relevant for talloc pools and the alignment to 16 bytes would increase the + memory footprint of each talloc chunk by those 16 bytes. +*/ + +#define TALLOC_POOL_HDR_SIZE 16 + +static unsigned int *talloc_pool_objectcount(struct talloc_chunk *tc) +{ + return (unsigned int *)((char *)tc + sizeof(struct talloc_chunk)); +} + +/* + Allocate from a pool +*/ + +static struct talloc_chunk *talloc_alloc_pool(struct talloc_chunk *parent, + size_t size) +{ + struct talloc_chunk *pool_ctx = NULL; + size_t space_left; + struct talloc_chunk *result; + size_t chunk_size; + + if (parent == NULL) { + return NULL; + } + + if (parent->flags & TALLOC_FLAG_POOL) { + pool_ctx = parent; + } + else if (parent->flags & TALLOC_FLAG_POOLMEM) { + pool_ctx = (struct talloc_chunk *)parent->pool; + } + + if (pool_ctx == NULL) { + return NULL; + } + + space_left = ((char *)pool_ctx + TC_HDR_SIZE + pool_ctx->size) + - ((char *)pool_ctx->pool); + + /* + * Align size to 16 bytes + */ + chunk_size = ((size + 15) & ~15); + + if (space_left < chunk_size) { + return NULL; + } + + result = (struct talloc_chunk *)pool_ctx->pool; + +#if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_UNDEFINED) + VALGRIND_MAKE_MEM_UNDEFINED(result, size); +#endif + + pool_ctx->pool = (void *)((char *)result + chunk_size); + + result->flags = TALLOC_MAGIC | TALLOC_FLAG_POOLMEM; + result->pool = pool_ctx; + + *talloc_pool_objectcount(pool_ctx) += 1; + + return result; +} + +/* + Allocate a bit of memory as a child of an existing pointer +*/ +static inline void *__talloc(const void *context, size_t size) +{ + struct talloc_chunk *tc = NULL; + + if (unlikely(context == NULL)) { + context = null_context; + } + + if (unlikely(size >= MAX_TALLOC_SIZE)) { + return NULL; + } + + if (context != NULL) { + tc = talloc_alloc_pool(talloc_chunk_from_ptr(context), + TC_HDR_SIZE+size); + } + + if (tc == NULL) { + tc = (struct talloc_chunk *)malloc(TC_HDR_SIZE+size); + if (unlikely(tc == NULL)) return NULL; + tc->flags = TALLOC_MAGIC; + tc->pool = NULL; + } + + tc->size = size; + tc->destructor = NULL; + tc->child = NULL; + tc->name = NULL; + tc->refs = NULL; + + if (likely(context)) { + struct talloc_chunk *parent = talloc_chunk_from_ptr(context); + + if (parent->child) { + parent->child->parent = NULL; + tc->next = parent->child; + tc->next->prev = tc; + } else { + tc->next = NULL; + } + tc->parent = parent; + tc->prev = NULL; + parent->child = tc; + } else { + tc->next = tc->prev = tc->parent = NULL; + } + + return TC_PTR_FROM_CHUNK(tc); +} + +/* + * Create a talloc pool + */ + +void *talloc_pool(const void *context, size_t size) +{ + void *result = __talloc(context, size + TALLOC_POOL_HDR_SIZE); + struct talloc_chunk *tc; + + if (unlikely(result == NULL)) { + return NULL; + } + + tc = talloc_chunk_from_ptr(result); + + tc->flags |= TALLOC_FLAG_POOL; + tc->pool = (char *)result + TALLOC_POOL_HDR_SIZE; + + *talloc_pool_objectcount(tc) = 1; + +#if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_NOACCESS) + VALGRIND_MAKE_MEM_NOACCESS(tc->pool, size); +#endif + + return result; +} + +/* + setup a destructor to be called on free of a pointer + the destructor should return 0 on success, or -1 on failure. + if the destructor fails then the free is failed, and the memory can + be continued to be used +*/ +void _talloc_set_destructor(const void *ptr, int (*destructor)(void *)) +{ + struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr); + tc->destructor = destructor; +} + +/* + increase the reference count on a piece of memory. +*/ +int talloc_increase_ref_count(const void *ptr) +{ + if (unlikely(!talloc_reference(null_context, ptr))) { + return -1; + } + return 0; +} + +/* + helper for talloc_reference() + + this is referenced by a function pointer and should not be inline +*/ +static int talloc_reference_destructor(struct talloc_reference_handle *handle) +{ + struct talloc_chunk *ptr_tc = talloc_chunk_from_ptr(handle->ptr); + _TLIST_REMOVE(ptr_tc->refs, handle); + return 0; +} + +/* + more efficient way to add a name to a pointer - the name must point to a + true string constant +*/ +static inline void _talloc_set_name_const(const void *ptr, const char *name) +{ + struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr); + tc->name = name; +} + +/* + internal talloc_named_const() +*/ +static inline void *_talloc_named_const(const void *context, size_t size, const char *name) +{ + void *ptr; + + ptr = __talloc(context, size); + if (unlikely(ptr == NULL)) { + return NULL; + } + + _talloc_set_name_const(ptr, name); + + return ptr; +} + +/* + make a secondary reference to a pointer, hanging off the given context. + the pointer remains valid until both the original caller and this given + context are freed. + + the major use for this is when two different structures need to reference the + same underlying data, and you want to be able to free the two instances separately, + and in either order +*/ +void *_talloc_reference(const void *context, const void *ptr) +{ + struct talloc_chunk *tc; + struct talloc_reference_handle *handle; + if (unlikely(ptr == NULL)) return NULL; + + tc = talloc_chunk_from_ptr(ptr); + handle = (struct talloc_reference_handle *)_talloc_named_const(context, + sizeof(struct talloc_reference_handle), + TALLOC_MAGIC_REFERENCE); + if (unlikely(handle == NULL)) return NULL; + + /* note that we hang the destructor off the handle, not the + main context as that allows the caller to still setup their + own destructor on the context if they want to */ + talloc_set_destructor(handle, talloc_reference_destructor); + handle->ptr = discard_const_p(void, ptr); + _TLIST_ADD(tc->refs, handle); + return handle->ptr; +} + + +/* + internal talloc_free call +*/ +static inline int _talloc_free(void *ptr) +{ + struct talloc_chunk *tc; + + if (unlikely(ptr == NULL)) { + return -1; + } + + tc = talloc_chunk_from_ptr(ptr); + + if (unlikely(tc->refs)) { + int is_child; + /* check this is a reference from a child or grantchild + * back to it's parent or grantparent + * + * in that case we need to remove the reference and + * call another instance of talloc_free() on the current + * pointer. + */ + is_child = talloc_is_parent(tc->refs, ptr); + _talloc_free(tc->refs); + if (is_child) { + return _talloc_free(ptr); + } + return -1; + } + + if (unlikely(tc->flags & TALLOC_FLAG_LOOP)) { + /* we have a free loop - stop looping */ + return 0; + } + + if (unlikely(tc->destructor)) { + talloc_destructor_t d = tc->destructor; + if (d == (talloc_destructor_t)-1) { + return -1; + } + tc->destructor = (talloc_destructor_t)-1; + if (d(ptr) == -1) { + tc->destructor = d; + return -1; + } + tc->destructor = NULL; + } + + if (tc->parent) { + _TLIST_REMOVE(tc->parent->child, tc); + if (tc->parent->child) { + tc->parent->child->parent = tc->parent; + } + } else { + if (tc->prev) tc->prev->next = tc->next; + if (tc->next) tc->next->prev = tc->prev; + } + + tc->flags |= TALLOC_FLAG_LOOP; + + while (tc->child) { + /* we need to work out who will own an abandoned child + if it cannot be freed. In priority order, the first + choice is owner of any remaining reference to this + pointer, the second choice is our parent, and the + final choice is the null context. */ + void *child = TC_PTR_FROM_CHUNK(tc->child); + const void *new_parent = null_context; + if (unlikely(tc->child->refs)) { + struct talloc_chunk *p = talloc_parent_chunk(tc->child->refs); + if (p) new_parent = TC_PTR_FROM_CHUNK(p); + } + if (unlikely(_talloc_free(child) == -1)) { + if (new_parent == null_context) { + struct talloc_chunk *p = talloc_parent_chunk(ptr); + if (p) new_parent = TC_PTR_FROM_CHUNK(p); + } + talloc_steal(new_parent, child); + } + } + + tc->flags |= TALLOC_FLAG_FREE; + + if (tc->flags & (TALLOC_FLAG_POOL|TALLOC_FLAG_POOLMEM)) { + struct talloc_chunk *pool; + unsigned int *pool_object_count; + + pool = (tc->flags & TALLOC_FLAG_POOL) + ? tc : (struct talloc_chunk *)tc->pool; + + pool_object_count = talloc_pool_objectcount(pool); + + if (*pool_object_count == 0) { + talloc_abort("Pool object count zero!"); + } + + *pool_object_count -= 1; + + if (*pool_object_count == 0) { + free(pool); + } + } + else { + free(tc); + } + return 0; +} + +/* + move a lump of memory from one talloc context to another return the + ptr on success, or NULL if it could not be transferred. + passing NULL as ptr will always return NULL with no side effects. +*/ +void *_talloc_steal(const void *new_ctx, const void *ptr) +{ + struct talloc_chunk *tc, *new_tc; + + if (unlikely(!ptr)) { + return NULL; + } + + if (unlikely(new_ctx == NULL)) { + new_ctx = null_context; + } + + tc = talloc_chunk_from_ptr(ptr); + + if (unlikely(new_ctx == NULL)) { + if (tc->parent) { + _TLIST_REMOVE(tc->parent->child, tc); + if (tc->parent->child) { + tc->parent->child->parent = tc->parent; + } + } else { + if (tc->prev) tc->prev->next = tc->next; + if (tc->next) tc->next->prev = tc->prev; + } + + tc->parent = tc->next = tc->prev = NULL; + return discard_const_p(void, ptr); + } + + new_tc = talloc_chunk_from_ptr(new_ctx); + + if (unlikely(tc == new_tc || tc->parent == new_tc)) { + return discard_const_p(void, ptr); + } + + if (tc->parent) { + _TLIST_REMOVE(tc->parent->child, tc); + if (tc->parent->child) { + tc->parent->child->parent = tc->parent; + } + } else { + if (tc->prev) tc->prev->next = tc->next; + if (tc->next) tc->next->prev = tc->prev; + } + + tc->parent = new_tc; + if (new_tc->child) new_tc->child->parent = NULL; + _TLIST_ADD(new_tc->child, tc); + + return discard_const_p(void, ptr); +} + + + +/* + remove a secondary reference to a pointer. This undo's what + talloc_reference() has done. The context and pointer arguments + must match those given to a talloc_reference() +*/ +static inline int talloc_unreference(const void *context, const void *ptr) +{ + struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr); + struct talloc_reference_handle *h; + + if (unlikely(context == NULL)) { + context = null_context; + } + + for (h=tc->refs;h;h=h->next) { + struct talloc_chunk *p = talloc_parent_chunk(h); + if (p == NULL) { + if (context == NULL) break; + } else if (TC_PTR_FROM_CHUNK(p) == context) { + break; + } + } + if (h == NULL) { + return -1; + } + + return _talloc_free(h); +} + +/* + remove a specific parent context from a pointer. This is a more + controlled varient of talloc_free() +*/ +int talloc_unlink(const void *context, void *ptr) +{ + struct talloc_chunk *tc_p, *new_p; + void *new_parent; + + if (ptr == NULL) { + return -1; + } + + if (context == NULL) { + context = null_context; + } + + if (talloc_unreference(context, ptr) == 0) { + return 0; + } + + if (context == NULL) { + if (talloc_parent_chunk(ptr) != NULL) { + return -1; + } + } else { + if (talloc_chunk_from_ptr(context) != talloc_parent_chunk(ptr)) { + return -1; + } + } + + tc_p = talloc_chunk_from_ptr(ptr); + + if (tc_p->refs == NULL) { + return _talloc_free(ptr); + } + + new_p = talloc_parent_chunk(tc_p->refs); + if (new_p) { + new_parent = TC_PTR_FROM_CHUNK(new_p); + } else { + new_parent = NULL; + } + + if (talloc_unreference(new_parent, ptr) != 0) { + return -1; + } + + talloc_steal(new_parent, ptr); + + return 0; +} + +/* + add a name to an existing pointer - va_list version +*/ +static inline const char *talloc_set_name_v(const void *ptr, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0); + +static inline const char *talloc_set_name_v(const void *ptr, const char *fmt, va_list ap) +{ + struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr); + tc->name = talloc_vasprintf(ptr, fmt, ap); + if (likely(tc->name)) { + _talloc_set_name_const(tc->name, ".name"); + } + return tc->name; +} + +/* + add a name to an existing pointer +*/ +const char *talloc_set_name(const void *ptr, const char *fmt, ...) +{ + const char *name; + va_list ap; + va_start(ap, fmt); + name = talloc_set_name_v(ptr, fmt, ap); + va_end(ap); + return name; +} + + +/* + create a named talloc pointer. Any talloc pointer can be named, and + talloc_named() operates just like talloc() except that it allows you + to name the pointer. +*/ +void *talloc_named(const void *context, size_t size, const char *fmt, ...) +{ + va_list ap; + void *ptr; + const char *name; + + ptr = __talloc(context, size); + if (unlikely(ptr == NULL)) return NULL; + + va_start(ap, fmt); + name = talloc_set_name_v(ptr, fmt, ap); + va_end(ap); + + if (unlikely(name == NULL)) { + _talloc_free(ptr); + return NULL; + } + + return ptr; +} + +/* + return the name of a talloc ptr, or "UNNAMED" +*/ +const char *talloc_get_name(const void *ptr) +{ + struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr); + if (unlikely(tc->name == TALLOC_MAGIC_REFERENCE)) { + return ".reference"; + } + if (likely(tc->name)) { + return tc->name; + } + return "UNNAMED"; +} + + +/* + check if a pointer has the given name. If it does, return the pointer, + otherwise return NULL +*/ +void *talloc_check_name(const void *ptr, const char *name) +{ + const char *pname; + if (unlikely(ptr == NULL)) return NULL; + pname = talloc_get_name(ptr); + if (likely(pname == name || strcmp(pname, name) == 0)) { + return discard_const_p(void, ptr); + } + return NULL; +} + +static void talloc_abort_type_missmatch(const char *location, + const char *name, + const char *expected) +{ + const char *reason; + + reason = talloc_asprintf(NULL, + "%s: Type mismatch: name[%s] expected[%s]", + location, + name?name:"NULL", + expected); + if (!reason) { + reason = "Type mismatch"; + } + + talloc_abort(reason); +} + +void *_talloc_get_type_abort(const void *ptr, const char *name, const char *location) +{ + const char *pname; + + if (unlikely(ptr == NULL)) { + talloc_abort_type_missmatch(location, NULL, name); + return NULL; + } + + pname = talloc_get_name(ptr); + if (likely(pname == name || strcmp(pname, name) == 0)) { + return discard_const_p(void, ptr); + } + + talloc_abort_type_missmatch(location, pname, name); + return NULL; +} + +/* + this is for compatibility with older versions of talloc +*/ +void *talloc_init(const char *fmt, ...) +{ + va_list ap; + void *ptr; + const char *name; + + /* + * samba3 expects talloc_report_depth_cb(NULL, ...) + * reports all talloc'ed memory, so we need to enable + * null_tracking + */ + talloc_enable_null_tracking(); + + ptr = __talloc(NULL, 0); + if (unlikely(ptr == NULL)) return NULL; + + va_start(ap, fmt); + name = talloc_set_name_v(ptr, fmt, ap); + va_end(ap); + + if (unlikely(name == NULL)) { + _talloc_free(ptr); + return NULL; + } + + return ptr; +} + +/* + this is a replacement for the Samba3 talloc_destroy_pool functionality. It + should probably not be used in new code. It's in here to keep the talloc + code consistent across Samba 3 and 4. +*/ +void talloc_free_children(void *ptr) +{ + struct talloc_chunk *tc; + + if (unlikely(ptr == NULL)) { + return; + } + + tc = talloc_chunk_from_ptr(ptr); + + while (tc->child) { + /* we need to work out who will own an abandoned child + if it cannot be freed. In priority order, the first + choice is owner of any remaining reference to this + pointer, the second choice is our parent, and the + final choice is the null context. */ + void *child = TC_PTR_FROM_CHUNK(tc->child); + const void *new_parent = null_context; + if (unlikely(tc->child->refs)) { + struct talloc_chunk *p = talloc_parent_chunk(tc->child->refs); + if (p) new_parent = TC_PTR_FROM_CHUNK(p); + } + if (unlikely(_talloc_free(child) == -1)) { + if (new_parent == null_context) { + struct talloc_chunk *p = talloc_parent_chunk(ptr); + if (p) new_parent = TC_PTR_FROM_CHUNK(p); + } + talloc_steal(new_parent, child); + } + } + + if ((tc->flags & TALLOC_FLAG_POOL) + && (*talloc_pool_objectcount(tc) == 1)) { + tc->pool = ((char *)tc + TC_HDR_SIZE + TALLOC_POOL_HDR_SIZE); +#if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_NOACCESS) + VALGRIND_MAKE_MEM_NOACCESS( + tc->pool, tc->size - TALLOC_POOL_HDR_SIZE); +#endif + } +} + +/* + Allocate a bit of memory as a child of an existing pointer +*/ +void *_talloc(const void *context, size_t size) +{ + return __talloc(context, size); +} + +/* + externally callable talloc_set_name_const() +*/ +void talloc_set_name_const(const void *ptr, const char *name) +{ + _talloc_set_name_const(ptr, name); +} + +/* + create a named talloc pointer. Any talloc pointer can be named, and + talloc_named() operates just like talloc() except that it allows you + to name the pointer. +*/ +void *talloc_named_const(const void *context, size_t size, const char *name) +{ + return _talloc_named_const(context, size, name); +} + +/* + free a talloc pointer. This also frees all child pointers of this + pointer recursively + + return 0 if the memory is actually freed, otherwise -1. The memory + will not be freed if the ref_count is > 1 or the destructor (if + any) returns non-zero +*/ +int talloc_free(void *ptr) +{ + return _talloc_free(ptr); +} + + + +/* + A talloc version of realloc. The context argument is only used if + ptr is NULL +*/ +void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *name) +{ + struct talloc_chunk *tc; + void *new_ptr; + bool malloced = false; + + /* size zero is equivalent to free() */ + if (unlikely(size == 0)) { + _talloc_free(ptr); + return NULL; + } + + if (unlikely(size >= MAX_TALLOC_SIZE)) { + return NULL; + } + + /* realloc(NULL) is equivalent to malloc() */ + if (ptr == NULL) { + return _talloc_named_const(context, size, name); + } + + tc = talloc_chunk_from_ptr(ptr); + + /* don't allow realloc on referenced pointers */ + if (unlikely(tc->refs)) { + return NULL; + } + + /* don't let anybody try to realloc a talloc_pool */ + if (unlikely(tc->flags & TALLOC_FLAG_POOL)) { + return NULL; + } + + /* don't shrink if we have less than 1k to gain */ + if ((size < tc->size) && ((tc->size - size) < 1024)) { + tc->size = size; + return ptr; + } + + /* by resetting magic we catch users of the old memory */ + tc->flags |= TALLOC_FLAG_FREE; + +#if ALWAYS_REALLOC + new_ptr = malloc(size + TC_HDR_SIZE); + if (new_ptr) { + memcpy(new_ptr, tc, tc->size + TC_HDR_SIZE); + free(tc); + } +#else + if (tc->flags & TALLOC_FLAG_POOLMEM) { + + new_ptr = talloc_alloc_pool(tc, size + TC_HDR_SIZE); + *talloc_pool_objectcount((struct talloc_chunk *) + (tc->pool)) -= 1; + + if (new_ptr == NULL) { + new_ptr = malloc(TC_HDR_SIZE+size); + malloced = true; + } + + if (new_ptr) { + memcpy(new_ptr, tc, MIN(tc->size,size) + TC_HDR_SIZE); + } + } + else { + new_ptr = realloc(tc, size + TC_HDR_SIZE); + } +#endif + if (unlikely(!new_ptr)) { + tc->flags &= ~TALLOC_FLAG_FREE; + return NULL; + } + + tc = (struct talloc_chunk *)new_ptr; + tc->flags &= ~TALLOC_FLAG_FREE; + if (malloced) { + tc->flags &= ~TALLOC_FLAG_POOLMEM; + } + if (tc->parent) { + tc->parent->child = tc; + } + if (tc->child) { + tc->child->parent = tc; + } + + if (tc->prev) { + tc->prev->next = tc; + } + if (tc->next) { + tc->next->prev = tc; + } + + tc->size = size; + _talloc_set_name_const(TC_PTR_FROM_CHUNK(tc), name); + + return TC_PTR_FROM_CHUNK(tc); +} + +/* + a wrapper around talloc_steal() for situations where you are moving a pointer + between two structures, and want the old pointer to be set to NULL +*/ +void *_talloc_move(const void *new_ctx, const void *_pptr) +{ + const void **pptr = discard_const_p(const void *,_pptr); + void *ret = _talloc_steal(new_ctx, *pptr); + (*pptr) = NULL; + return ret; +} + +/* + return the total size of a talloc pool (subtree) +*/ +size_t talloc_total_size(const void *ptr) +{ + size_t total = 0; + struct talloc_chunk *c, *tc; + + if (ptr == NULL) { + ptr = null_context; + } + if (ptr == NULL) { + return 0; + } + + tc = talloc_chunk_from_ptr(ptr); + + if (tc->flags & TALLOC_FLAG_LOOP) { + return 0; + } + + tc->flags |= TALLOC_FLAG_LOOP; + + total = tc->size; + for (c=tc->child;c;c=c->next) { + total += talloc_total_size(TC_PTR_FROM_CHUNK(c)); + } + + tc->flags &= ~TALLOC_FLAG_LOOP; + + return total; +} + +/* + return the total number of blocks in a talloc pool (subtree) +*/ +size_t talloc_total_blocks(const void *ptr) +{ + size_t total = 0; + struct talloc_chunk *c, *tc = talloc_chunk_from_ptr(ptr); + + if (tc->flags & TALLOC_FLAG_LOOP) { + return 0; + } + + tc->flags |= TALLOC_FLAG_LOOP; + + total++; + for (c=tc->child;c;c=c->next) { + total += talloc_total_blocks(TC_PTR_FROM_CHUNK(c)); + } + + tc->flags &= ~TALLOC_FLAG_LOOP; + + return total; +} + +/* + return the number of external references to a pointer +*/ +size_t talloc_reference_count(const void *ptr) +{ + struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr); + struct talloc_reference_handle *h; + size_t ret = 0; + + for (h=tc->refs;h;h=h->next) { + ret++; + } + return ret; +} + +/* + report on memory usage by all children of a pointer, giving a full tree view +*/ +void talloc_report_depth_cb(const void *ptr, int depth, int max_depth, + void (*callback)(const void *ptr, + int depth, int max_depth, + int is_ref, + void *private_data), + void *private_data) +{ + struct talloc_chunk *c, *tc; + + if (ptr == NULL) { + ptr = null_context; + } + if (ptr == NULL) return; + + tc = talloc_chunk_from_ptr(ptr); + + if (tc->flags & TALLOC_FLAG_LOOP) { + return; + } + + callback(ptr, depth, max_depth, 0, private_data); + + if (max_depth >= 0 && depth >= max_depth) { + return; + } + + tc->flags |= TALLOC_FLAG_LOOP; + for (c=tc->child;c;c=c->next) { + if (c->name == TALLOC_MAGIC_REFERENCE) { + struct talloc_reference_handle *h = (struct talloc_reference_handle *)TC_PTR_FROM_CHUNK(c); + callback(h->ptr, depth + 1, max_depth, 1, private_data); + } else { + talloc_report_depth_cb(TC_PTR_FROM_CHUNK(c), depth + 1, max_depth, callback, private_data); + } + } + tc->flags &= ~TALLOC_FLAG_LOOP; +} + +static void talloc_report_depth_FILE_helper(const void *ptr, int depth, int max_depth, int is_ref, void *_f) +{ + const char *name = talloc_get_name(ptr); + FILE *f = (FILE *)_f; + + if (is_ref) { + fprintf(f, "%*sreference to: %s\n", depth*4, "", name); + return; + } + + if (depth == 0) { + fprintf(f,"%stalloc report on '%s' (total %6lu bytes in %3lu blocks)\n", + (max_depth < 0 ? "full " :""), name, + (unsigned long)talloc_total_size(ptr), + (unsigned long)talloc_total_blocks(ptr)); + return; + } + + fprintf(f, "%*s%-30s contains %6lu bytes in %3lu blocks (ref %d) %p\n", + depth*4, "", + name, + (unsigned long)talloc_total_size(ptr), + (unsigned long)talloc_total_blocks(ptr), + (int)talloc_reference_count(ptr), ptr); + +#if 0 + fprintf(f, "content: "); + if (talloc_total_size(ptr)) { + int tot = talloc_total_size(ptr); + int i; + + for (i = 0; i < tot; i++) { + if ((((char *)ptr)[i] > 31) && (((char *)ptr)[i] < 126)) { + fprintf(f, "%c", ((char *)ptr)[i]); + } else { + fprintf(f, "~%02x", ((char *)ptr)[i]); + } + } + } + fprintf(f, "\n"); +#endif +} + +/* + report on memory usage by all children of a pointer, giving a full tree view +*/ +void talloc_report_depth_file(const void *ptr, int depth, int max_depth, FILE *f) +{ + talloc_report_depth_cb(ptr, depth, max_depth, talloc_report_depth_FILE_helper, f); + fflush(f); +} + +/* + report on memory usage by all children of a pointer, giving a full tree view +*/ +void talloc_report_full(const void *ptr, FILE *f) +{ + talloc_report_depth_file(ptr, 0, -1, f); +} + +/* + report on memory usage by all children of a pointer +*/ +void talloc_report(const void *ptr, FILE *f) +{ + talloc_report_depth_file(ptr, 0, 1, f); +} + +/* + report on any memory hanging off the null context +*/ +static void talloc_report_null(void) +{ + if (talloc_total_size(null_context) != 0) { + talloc_report(null_context, stderr); + } +} + +/* + report on any memory hanging off the null context +*/ +static void talloc_report_null_full(void) +{ + if (talloc_total_size(null_context) != 0) { + talloc_report_full(null_context, stderr); + } +} + +/* + enable tracking of the NULL context +*/ +void talloc_enable_null_tracking(void) +{ + if (null_context == NULL) { + null_context = _talloc_named_const(NULL, 0, "null_context"); + } +} + +/* + disable tracking of the NULL context +*/ +void talloc_disable_null_tracking(void) +{ + _talloc_free(null_context); + null_context = NULL; +} + +/* + enable leak reporting on exit +*/ +void talloc_enable_leak_report(void) +{ + talloc_enable_null_tracking(); + atexit(talloc_report_null); +} + +/* + enable full leak reporting on exit +*/ +void talloc_enable_leak_report_full(void) +{ + talloc_enable_null_tracking(); + atexit(talloc_report_null_full); +} + +/* + talloc and zero memory. +*/ +void *_talloc_zero(const void *ctx, size_t size, const char *name) +{ + void *p = _talloc_named_const(ctx, size, name); + + if (p) { + memset(p, '\0', size); + } + + return p; +} + +/* + memdup with a talloc. +*/ +void *_talloc_memdup(const void *t, const void *p, size_t size, const char *name) +{ + void *newp = _talloc_named_const(t, size, name); + + if (likely(newp)) { + memcpy(newp, p, size); + } + + return newp; +} + +static inline char *__talloc_strlendup(const void *t, const char *p, size_t len) +{ + char *ret; + + ret = (char *)__talloc(t, len + 1); + if (unlikely(!ret)) return NULL; + + memcpy(ret, p, len); + ret[len] = 0; + + _talloc_set_name_const(ret, ret); + return ret; +} + +/* + strdup with a talloc +*/ +char *talloc_strdup(const void *t, const char *p) +{ + if (unlikely(!p)) return NULL; + return __talloc_strlendup(t, p, strlen(p)); +} + +/* + strndup with a talloc +*/ +char *talloc_strndup(const void *t, const char *p, size_t n) +{ + if (unlikely(!p)) return NULL; + return __talloc_strlendup(t, p, strnlen(p, n)); +} + +static inline char *__talloc_strlendup_append(char *s, size_t slen, + const char *a, size_t alen) +{ + char *ret; + + ret = talloc_realloc(NULL, s, char, slen + alen + 1); + if (unlikely(!ret)) return NULL; + + /* append the string and the trailing \0 */ + memcpy(&ret[slen], a, alen); + ret[slen+alen] = 0; + + _talloc_set_name_const(ret, ret); + return ret; +} + +/* + * Appends at the end of the string. + */ +char *talloc_strdup_append(char *s, const char *a) +{ + if (unlikely(!s)) { + return talloc_strdup(NULL, a); + } + + if (unlikely(!a)) { + return s; + } + + return __talloc_strlendup_append(s, strlen(s), a, strlen(a)); +} + +/* + * Appends at the end of the talloc'ed buffer, + * not the end of the string. + */ +char *talloc_strdup_append_buffer(char *s, const char *a) +{ + size_t slen; + + if (unlikely(!s)) { + return talloc_strdup(NULL, a); + } + + if (unlikely(!a)) { + return s; + } + + slen = talloc_get_size(s); + if (likely(slen > 0)) { + slen--; + } + + return __talloc_strlendup_append(s, slen, a, strlen(a)); +} + +/* + * Appends at the end of the string. + */ +char *talloc_strndup_append(char *s, const char *a, size_t n) +{ + if (unlikely(!s)) { + return talloc_strdup(NULL, a); + } + + if (unlikely(!a)) { + return s; + } + + return __talloc_strlendup_append(s, strlen(s), a, strnlen(a, n)); +} + +/* + * Appends at the end of the talloc'ed buffer, + * not the end of the string. + */ +char *talloc_strndup_append_buffer(char *s, const char *a, size_t n) +{ + size_t slen; + + if (unlikely(!s)) { + return talloc_strdup(NULL, a); + } + + if (unlikely(!a)) { + return s; + } + + slen = talloc_get_size(s); + if (likely(slen > 0)) { + slen--; + } + + return __talloc_strlendup_append(s, slen, a, strnlen(a, n)); +} + +#ifndef HAVE_VA_COPY +#ifdef HAVE___VA_COPY +#define va_copy(dest, src) __va_copy(dest, src) +#else +#define va_copy(dest, src) (dest) = (src) +#endif +#endif + +char *talloc_vasprintf(const void *t, const char *fmt, va_list ap) +{ + int len; + char *ret; + va_list ap2; + char c; + + /* this call looks strange, but it makes it work on older solaris boxes */ + va_copy(ap2, ap); + len = vsnprintf(&c, 1, fmt, ap2); + va_end(ap2); + if (unlikely(len < 0)) { + return NULL; + } + + ret = (char *)__talloc(t, len+1); + if (unlikely(!ret)) return NULL; + + va_copy(ap2, ap); + vsnprintf(ret, len+1, fmt, ap2); + va_end(ap2); + + _talloc_set_name_const(ret, ret); + return ret; +} + + +/* + Perform string formatting, and return a pointer to newly allocated + memory holding the result, inside a memory pool. + */ +char *talloc_asprintf(const void *t, const char *fmt, ...) +{ + va_list ap; + char *ret; + + va_start(ap, fmt); + ret = talloc_vasprintf(t, fmt, ap); + va_end(ap); + return ret; +} + +static inline char *__talloc_vaslenprintf_append(char *s, size_t slen, + const char *fmt, va_list ap) + PRINTF_ATTRIBUTE(3,0); + +static inline char *__talloc_vaslenprintf_append(char *s, size_t slen, + const char *fmt, va_list ap) +{ + ssize_t alen; + va_list ap2; + char c; + + va_copy(ap2, ap); + alen = vsnprintf(&c, 1, fmt, ap2); + va_end(ap2); + + if (alen <= 0) { + /* Either the vsnprintf failed or the format resulted in + * no characters being formatted. In the former case, we + * ought to return NULL, in the latter we ought to return + * the original string. Most current callers of this + * function expect it to never return NULL. + */ + return s; + } + + s = talloc_realloc(NULL, s, char, slen + alen + 1); + if (!s) return NULL; + + va_copy(ap2, ap); + vsnprintf(s + slen, alen + 1, fmt, ap2); + va_end(ap2); + + _talloc_set_name_const(s, s); + return s; +} + +/** + * Realloc @p s to append the formatted result of @p fmt and @p ap, + * and return @p s, which may have moved. Good for gradually + * accumulating output into a string buffer. Appends at the end + * of the string. + **/ +char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap) +{ + if (unlikely(!s)) { + return talloc_vasprintf(NULL, fmt, ap); + } + + return __talloc_vaslenprintf_append(s, strlen(s), fmt, ap); +} + +/** + * Realloc @p s to append the formatted result of @p fmt and @p ap, + * and return @p s, which may have moved. Always appends at the + * end of the talloc'ed buffer, not the end of the string. + **/ +char *talloc_vasprintf_append_buffer(char *s, const char *fmt, va_list ap) +{ + size_t slen; + + if (unlikely(!s)) { + return talloc_vasprintf(NULL, fmt, ap); + } + + slen = talloc_get_size(s); + if (likely(slen > 0)) { + slen--; + } + + return __talloc_vaslenprintf_append(s, slen, fmt, ap); +} + +/* + Realloc @p s to append the formatted result of @p fmt and return @p + s, which may have moved. Good for gradually accumulating output + into a string buffer. + */ +char *talloc_asprintf_append(char *s, const char *fmt, ...) +{ + va_list ap; + + va_start(ap, fmt); + s = talloc_vasprintf_append(s, fmt, ap); + va_end(ap); + return s; +} + +/* + Realloc @p s to append the formatted result of @p fmt and return @p + s, which may have moved. Good for gradually accumulating output + into a buffer. + */ +char *talloc_asprintf_append_buffer(char *s, const char *fmt, ...) +{ + va_list ap; + + va_start(ap, fmt); + s = talloc_vasprintf_append_buffer(s, fmt, ap); + va_end(ap); + return s; +} + +/* + alloc an array, checking for integer overflow in the array size +*/ +void *_talloc_array(const void *ctx, size_t el_size, unsigned count, const char *name) +{ + if (count >= MAX_TALLOC_SIZE/el_size) { + return NULL; + } + return _talloc_named_const(ctx, el_size * count, name); +} + +/* + alloc an zero array, checking for integer overflow in the array size +*/ +void *_talloc_zero_array(const void *ctx, size_t el_size, unsigned count, const char *name) +{ + if (count >= MAX_TALLOC_SIZE/el_size) { + return NULL; + } + return _talloc_zero(ctx, el_size * count, name); +} + +/* + realloc an array, checking for integer overflow in the array size +*/ +void *_talloc_realloc_array(const void *ctx, void *ptr, size_t el_size, unsigned count, const char *name) +{ + if (count >= MAX_TALLOC_SIZE/el_size) { + return NULL; + } + return _talloc_realloc(ctx, ptr, el_size * count, name); +} + +/* + a function version of talloc_realloc(), so it can be passed as a function pointer + to libraries that want a realloc function (a realloc function encapsulates + all the basic capabilities of an allocation library, which is why this is useful) +*/ +void *talloc_realloc_fn(const void *context, void *ptr, size_t size) +{ + return _talloc_realloc(context, ptr, size, NULL); +} + + +static int talloc_autofree_destructor(void *ptr) +{ + autofree_context = NULL; + return 0; +} + +static void talloc_autofree(void) +{ + _talloc_free(autofree_context); +} + +/* + return a context which will be auto-freed on exit + this is useful for reducing the noise in leak reports +*/ +void *talloc_autofree_context(void) +{ + if (autofree_context == NULL) { + autofree_context = _talloc_named_const(NULL, 0, "autofree_context"); + talloc_set_destructor(autofree_context, talloc_autofree_destructor); + atexit(talloc_autofree); + } + return autofree_context; +} + +size_t talloc_get_size(const void *context) +{ + struct talloc_chunk *tc; + + if (context == NULL) + return 0; + + tc = talloc_chunk_from_ptr(context); + + return tc->size; +} + +/* + find a parent of this context that has the given name, if any +*/ +void *talloc_find_parent_byname(const void *context, const char *name) +{ + struct talloc_chunk *tc; + + if (context == NULL) { + return NULL; + } + + tc = talloc_chunk_from_ptr(context); + while (tc) { + if (tc->name && strcmp(tc->name, name) == 0) { + return TC_PTR_FROM_CHUNK(tc); + } + while (tc && tc->prev) tc = tc->prev; + if (tc) { + tc = tc->parent; + } + } + return NULL; +} + +/* + show the parentage of a context +*/ +void talloc_show_parents(const void *context, FILE *file) +{ + struct talloc_chunk *tc; + + if (context == NULL) { + fprintf(file, "talloc no parents for NULL\n"); + return; + } + + tc = talloc_chunk_from_ptr(context); + fprintf(file, "talloc parents of '%s'\n", talloc_get_name(context)); + while (tc) { + fprintf(file, "\t'%s'\n", talloc_get_name(TC_PTR_FROM_CHUNK(tc))); + while (tc && tc->prev) tc = tc->prev; + if (tc) { + tc = tc->parent; + } + } + fflush(file); +} + +/* + return 1 if ptr is a parent of context +*/ +int talloc_is_parent(const void *context, const void *ptr) +{ + struct talloc_chunk *tc; + + if (context == NULL) { + return 0; + } + + tc = talloc_chunk_from_ptr(context); + while (tc) { + if (TC_PTR_FROM_CHUNK(tc) == ptr) return 1; + while (tc && tc->prev) tc = tc->prev; + if (tc) { + tc = tc->parent; + } + } + return 0; +} diff --git a/openbsc/src/telnet_interface.c b/openbsc/src/telnet_interface.c index f4ffb529e..8b9fd7983 100644 --- a/openbsc/src/telnet_interface.c +++ b/openbsc/src/telnet_interface.c @@ -34,6 +34,7 @@ #include #include #include +#include #include @@ -47,6 +48,8 @@ /* per connection data */ LLIST_HEAD(active_connections); +static void *tall_telnet_ctx; + /* per network data */ static int telnet_new_connection(struct bsc_fd *fd, unsigned int what); #if 0 @@ -66,6 +69,9 @@ void telnet_init(struct gsm_network *network, int port) { struct sockaddr_in sock_addr; int fd, on = 1; + tall_telnet_ctx = talloc_named_const(tall_bsc_ctx, 1, + "telnet_connection"); + bsc_vty_init(network); fd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP); @@ -161,7 +167,7 @@ static int telnet_new_connection(struct bsc_fd *fd, unsigned int what) { } - connection = (struct telnet_connection*)malloc(sizeof(*connection)); + connection = talloc(tall_telnet_ctx, struct telnet_connection); memset(connection, 0, sizeof(*connection)); connection->network = (struct gsm_network*)fd->data; connection->fd.data = connection; diff --git a/openbsc/src/trau_mux.c b/openbsc/src/trau_mux.c index 196d15fa7..7615b6294 100644 --- a/openbsc/src/trau_mux.c +++ b/openbsc/src/trau_mux.c @@ -30,6 +30,7 @@ #include #include #include +#include struct map_entry { struct llist_head list; @@ -46,11 +47,19 @@ struct upqueue_entry { static LLIST_HEAD(ss_map); static LLIST_HEAD(ss_upqueue); +static void *tall_map_ctx, *tall_upq_ctx; + /* map one particular subslot to another subslot */ int trau_mux_map(const struct gsm_e1_subslot *src, const struct gsm_e1_subslot *dst) { - struct map_entry *me = malloc(sizeof(*me)); + struct map_entry *me; + + if (!tall_map_ctx) + tall_map_ctx = talloc_named_const(tall_bsc_ctx, 1, + "trau_map_entry"); + + me = talloc(tall_map_ctx, struct map_entry); if (!me) return -ENOMEM; @@ -189,8 +198,13 @@ int trau_mux_input(struct gsm_e1_subslot *src_e1_ss, int trau_recv_lchan(struct gsm_lchan *lchan, u_int32_t callref) { struct gsm_e1_subslot *src_ss; - struct upqueue_entry *ue = malloc(sizeof(*ue)); + struct upqueue_entry *ue; + + if (!tall_upq_ctx) + tall_upq_ctx = talloc_named_const(tall_bsc_ctx, 1, + "trau_upq_entry"); + ue = talloc(tall_upq_ctx, struct upqueue_entry); if (!ue) return -ENOMEM; -- cgit v1.2.3 From e441d9c36174037f50245a0dc47c4ec41b3b5421 Mon Sep 17 00:00:00 2001 From: Harald Welte Date: Sun, 21 Jun 2009 16:17:15 +0200 Subject: switch to dynamically allocated BTS and TRX data structures This makes it much easier to do run-time configuration using the vty interface. --- openbsc/include/openbsc/gsm_data.h | 22 ++++-- openbsc/src/abis_nm.c | 16 ++-- openbsc/src/bs11_config.c | 21 ++++-- openbsc/src/bsc_hack.c | 23 +++--- openbsc/src/chan_alloc.c | 13 ++-- openbsc/src/gsm_04_08.c | 4 +- openbsc/src/gsm_data.c | 151 ++++++++++++++++++++++++------------- openbsc/src/input/ipaccess.c | 4 +- openbsc/src/ipaccess-config.c | 5 +- openbsc/src/vty_interface.c | 73 ++++++++++-------- 10 files changed, 204 insertions(+), 128 deletions(-) (limited to 'openbsc') diff --git a/openbsc/include/openbsc/gsm_data.h b/openbsc/include/openbsc/gsm_data.h index f300d31bb..9b4cf9df3 100644 --- a/openbsc/include/openbsc/gsm_data.h +++ b/openbsc/include/openbsc/gsm_data.h @@ -46,8 +46,6 @@ enum gsm_chreq_reason_t { #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) -#define GSM_MAX_BTS 8 -#define BTS_MAX_TRX 8 #define TRX_NR_TS 8 #define TS_MAX_LCHAN 8 @@ -216,6 +214,9 @@ struct gsm_bts_trx_ts { /* One TRX in a BTS */ struct gsm_bts_trx { + /* list header in bts->trx_list */ + struct llist_head list; + struct gsm_bts *bts; /* number of this TRX in the BTS */ u_int8_t nr; @@ -297,6 +298,9 @@ struct gsm_envabtse { /* One BTS */ struct gsm_bts { + /* list header in net->bts_list */ + struct llist_head list; + struct gsm_network *network; /* number of ths BTS in network */ u_int8_t nr; @@ -351,7 +355,7 @@ struct gsm_bts { /* transceivers */ int num_trx; - struct gsm_bts_trx trx[BTS_MAX_TRX+1]; + struct llist_head trx_list; }; struct gsm_network { @@ -367,8 +371,7 @@ struct gsm_network { struct llist_head trans_list; unsigned int num_bts; - /* private lists */ - struct gsm_bts bts[GSM_MAX_BTS+1]; + struct llist_head bts_list; }; #define SMS_HDR_SIZE 128 @@ -382,9 +385,14 @@ struct gsm_sms { char text[SMS_TEXT_SIZE]; }; -struct gsm_network *gsm_network_init(unsigned int num_bts, enum gsm_bts_type bts_type, - u_int16_t country_code, u_int16_t network_code, +struct gsm_network *gsm_network_init(u_int16_t country_code, u_int16_t network_code, int (*mncc_recv)(struct gsm_network *, int, void *)); +struct gsm_bts *gsm_bts_alloc(struct gsm_network *net, enum gsm_bts_type type, + u_int8_t tsc, u_int8_t bsic); +struct gsm_bts_trx *gsm_bts_trx_alloc(struct gsm_bts *bts); + +struct gsm_bts *gsm_bts_num(struct gsm_network *net, int num); +struct gsm_bts_trx *gsm_bts_trx_num(struct gsm_bts *bts, int num); const char *gsm_pchan_name(enum gsm_phys_chan_config c); const char *gsm_lchan_name(enum gsm_chan_t c); diff --git a/openbsc/src/abis_nm.c b/openbsc/src/abis_nm.c index bd3ba19e1..5040541e0 100644 --- a/openbsc/src/abis_nm.c +++ b/openbsc/src/abis_nm.c @@ -544,19 +544,19 @@ objclass2nmstate(struct gsm_bts *bts, u_int8_t obj_class, case NM_OC_RADIO_CARRIER: if (obj_inst->trx_nr >= bts->num_trx) return NULL; - trx = &bts->trx[obj_inst->trx_nr]; + trx = gsm_bts_trx_num(bts, obj_inst->trx_nr); nm_state = &trx->nm_state; break; case NM_OC_BASEB_TRANSC: if (obj_inst->trx_nr >= bts->num_trx) return NULL; - trx = &bts->trx[obj_inst->trx_nr]; + trx = gsm_bts_trx_num(bts, obj_inst->trx_nr); nm_state = &trx->bb_transc.nm_state; break; case NM_OC_CHANNEL: if (obj_inst->trx_nr > bts->num_trx) return NULL; - trx = &bts->trx[obj_inst->trx_nr]; + trx = gsm_bts_trx_num(bts, obj_inst->trx_nr); if (obj_inst->ts_nr >= TRX_NR_TS) return NULL; nm_state = &trx->ts[obj_inst->ts_nr].nm_state; @@ -572,13 +572,13 @@ objclass2nmstate(struct gsm_bts *bts, u_int8_t obj_class, case BS11_OBJ_BBSIG: if (obj_inst->ts_nr > bts->num_trx) return NULL; - trx = &bts->trx[obj_inst->ts_nr]; + trx = gsm_bts_trx_num(bts, obj_inst->trx_nr); nm_state = &trx->bs11.bbsig.nm_state; break; case BS11_OBJ_PA: if (obj_inst->ts_nr > bts->num_trx) return NULL; - trx = &bts->trx[obj_inst->ts_nr]; + trx = gsm_bts_trx_num(bts, obj_inst->trx_nr); nm_state = &trx->bs11.pa.nm_state; break; default: @@ -611,19 +611,19 @@ objclass2obj(struct gsm_bts *bts, u_int8_t obj_class, case NM_OC_RADIO_CARRIER: if (obj_inst->trx_nr >= bts->num_trx) return NULL; - trx = &bts->trx[obj_inst->trx_nr]; + trx = gsm_bts_trx_num(bts, obj_inst->trx_nr); obj = trx; break; case NM_OC_BASEB_TRANSC: if (obj_inst->trx_nr >= bts->num_trx) return NULL; - trx = &bts->trx[obj_inst->trx_nr]; + trx = gsm_bts_trx_num(bts, obj_inst->trx_nr); obj = &trx->bb_transc; break; case NM_OC_CHANNEL: if (obj_inst->trx_nr > bts->num_trx) return NULL; - trx = &bts->trx[obj_inst->trx_nr]; + trx = gsm_bts_trx_num(bts, obj_inst->trx_nr); if (obj_inst->ts_nr >= TRX_NR_TS) return NULL; obj = &trx->ts[obj_inst->ts_nr]; diff --git a/openbsc/src/bs11_config.c b/openbsc/src/bs11_config.c index 386b865ca..0fb7cd7a6 100644 --- a/openbsc/src/bs11_config.c +++ b/openbsc/src/bs11_config.c @@ -94,7 +94,7 @@ static int create_objects(struct gsm_bts *bts) abis_nm_bs11_conn_oml_tei(bts, 0, 1, 0xff, TEI_OML); - abis_nm_bs11_set_trx_power(&bts->trx[0], BS11_TRX_POWER_GSM_30mW); + abis_nm_bs11_set_trx_power(bts->c0, BS11_TRX_POWER_GSM_30mW); sleep(1); @@ -109,6 +109,10 @@ static int create_trx1(struct gsm_bts *bts) { u_int8_t bbsig1_attr[sizeof(obj_bbsig0_attr)+12]; u_int8_t *cur = bbsig1_attr; + struct gsm_bts_trx *trx = gsm_bts_trx_num(bts, 1); + + if (!trx) + trx = gsm_bts_trx_alloc(bts); fprintf(stdout, "Crating Objects for TRX1\n"); @@ -123,7 +127,7 @@ static int create_trx1(struct gsm_bts *bts) sizeof(bbsig1_attr), bbsig1_attr); abis_nm_bs11_create_object(bts, BS11_OBJ_PA, 1, sizeof(obj_pa0_attr), obj_pa0_attr); - abis_nm_bs11_set_trx_power(&bts->trx[1], BS11_TRX_POWER_GSM_30mW); + abis_nm_bs11_set_trx_power(trx, BS11_TRX_POWER_GSM_30mW); return 0; } @@ -437,13 +441,17 @@ static int print_attr(struct tlv_parsed *tp) static void cmd_query(void) { + struct gsm_bts_trx *trx = g_bts->c0; + bs11cfg_state = STATE_QUERY; abis_nm_bs11_get_serno(g_bts); abis_nm_bs11_get_oml_tei_ts(g_bts); abis_nm_bs11_get_pll_mode(g_bts); abis_nm_bs11_get_cclk(g_bts); - abis_nm_bs11_get_trx_power(&g_bts->trx[0]); - abis_nm_bs11_get_trx_power(&g_bts->trx[1]); + abis_nm_bs11_get_trx_power(trx); + trx = gsm_bts_trx_num(g_bts, 1); + if (trx) + abis_nm_bs11_get_trx_power(trx); sleep(1); abis_nm_bs11_factory_logon(g_bts, 0); command = NULL; @@ -775,12 +783,13 @@ int main(int argc, char **argv) handle_options(argc, argv); - gsmnet = gsm_network_init(1, 1, 1, GSM_BTS_TYPE_BS11, NULL); + gsmnet = gsm_network_init(1, 1, NULL); if (!gsmnet) { fprintf(stderr, "Unable to allocate gsm network\n"); exit(1); } - g_bts = &gsmnet->bts[0]; + g_bts = gsm_bts_alloc(gsmnet, GSM_BTS_TYPE_BS11, HARDCODED_TSC, + HARDCODED_BSIC); rc = rs232_setup(serial_port, delay_ms, g_bts); if (rc < 0) { diff --git a/openbsc/src/bsc_hack.c b/openbsc/src/bsc_hack.c index ae67ade31..e3e3a407f 100644 --- a/openbsc/src/bsc_hack.c +++ b/openbsc/src/bsc_hack.c @@ -490,7 +490,7 @@ static void bootstrap_om_nanobts(struct gsm_bts *bts) static void bootstrap_om_bs11(struct gsm_bts *bts) { - struct gsm_bts_trx *trx = &bts->trx[0]; + struct gsm_bts_trx *trx = bts->c0; /* stop sending event reports */ abis_nm_event_reports(bts, 0); @@ -608,10 +608,11 @@ static int shutdown_om(struct gsm_bts *bts) static int shutdown_net(struct gsm_network *net) { - int i; - for (i = 0; i < net->num_bts; i++) { + struct gsm_bts *bts; + + llist_for_each_entry(bts, &net->bts_list, list) { int rc; - rc = shutdown_om(&net->bts[i]); + rc = shutdown_om(bts); if (rc < 0) return rc; } @@ -849,8 +850,8 @@ static int set_system_infos(struct gsm_bts_trx *trx) */ static void patch_tables(struct gsm_bts *bts) { - u_int8_t arfcn_low = bts->trx[0].arfcn & 0xff; - u_int8_t arfcn_high = (bts->trx[0].arfcn >> 8) & 0x0f; + u_int8_t arfcn_low = bts->c0->arfcn & 0xff; + u_int8_t arfcn_high = (bts->c0->arfcn >> 8) & 0x0f; /* covert the raw packet to the struct */ struct gsm48_system_information_type_3 *type_3 = (struct gsm48_system_information_type_3*)&si3; @@ -933,7 +934,7 @@ static int bootstrap_bts(struct gsm_bts *bts) { bts->band = BAND; bts->location_area_code = LAC; - bts->trx[0].arfcn = ARFCN; + bts->c0->arfcn = ARFCN; /* Control Channel Description */ memset(&bts->chan_desc, 0, sizeof(struct gsm48_control_channel_descr)); @@ -947,7 +948,7 @@ static int bootstrap_bts(struct gsm_bts *bts) paging_init(bts); if (bts->type == GSM_BTS_TYPE_BS11) { - struct gsm_bts_trx *trx = &bts->trx[0]; + struct gsm_bts_trx *trx = bts->c0; set_ts_e1link(&trx->ts[0], 0, 1, 0xff); set_ts_e1link(&trx->ts[1], 0, 2, 1); set_ts_e1link(&trx->ts[2], 0, 2, 2); @@ -998,14 +999,14 @@ static int bootstrap_network(void) } /* initialize our data structures */ - gsmnet = gsm_network_init(2, BTS_TYPE, MCC, MNC, mncc_recv); + gsmnet = gsm_network_init(MCC, MNC, mncc_recv); if (!gsmnet) return -ENOMEM; gsmnet->name_long = "OpenBSC"; gsmnet->name_short = "OpenBSC"; - bts = &gsmnet->bts[0]; + bts = gsm_bts_alloc(gsmnet, BTS_TYPE, HARDCODED_TSC, HARDCODED_BSIC); bootstrap_bts(bts); if (db_init(database_name)) { @@ -1033,7 +1034,7 @@ static int bootstrap_network(void) bts->ip_access.site_id = 1801; bts->ip_access.bts_id = 0; - bts = &gsmnet->bts[1]; + bts = gsm_bts_alloc(gsmnet, BTS_TYPE, HARDCODED_TSC, HARDCODED_BSIC); bootstrap_bts(bts); bts->ip_access.site_id = 1800; bts->ip_access.bts_id = 0; diff --git a/openbsc/src/chan_alloc.c b/openbsc/src/chan_alloc.c index 96632bcb9..241d5895b 100644 --- a/openbsc/src/chan_alloc.c +++ b/openbsc/src/chan_alloc.c @@ -38,7 +38,7 @@ static void auto_release_channel(void *_lchan); struct gsm_bts_trx_ts *ts_c0_alloc(struct gsm_bts *bts, enum gsm_phys_chan_config pchan) { - struct gsm_bts_trx *trx = &bts->trx[0]; + struct gsm_bts_trx *trx = bts->c0; struct gsm_bts_trx_ts *ts = &trx->ts[0]; if (pchan != GSM_PCHAN_CCCH && @@ -68,7 +68,7 @@ struct gsm_bts_trx_ts *ts_alloc(struct gsm_bts *bts, { int i, j; for (i = 0; i < bts->num_trx; i++) { - struct gsm_bts_trx *trx = &bts->trx[i]; + struct gsm_bts_trx *trx = gsm_bts_trx_num(bts, i); int from, to; /* the following constraints are pure policy, @@ -124,7 +124,7 @@ _lc_find(struct gsm_bts *bts, enum gsm_phys_chan_config pchan) struct gsm_bts_trx_ts *ts; int i, j, ss; for (i = 0; i < bts->num_trx; i++) { - trx = &bts->trx[i]; + trx = gsm_bts_trx_num(bts, i); for (j = 0; j < 8; j++) { ts = &trx->ts[j]; if (ts->pchan != pchan) @@ -239,13 +239,14 @@ static void auto_release_channel(void *_lchan) } struct gsm_lchan* lchan_find(struct gsm_bts *bts, struct gsm_subscriber *subscr) { - int trx, ts_no, lchan_no; + struct gsm_bts_trx *trx; + int ts_no, lchan_no; - for (trx = 0; trx < bts->num_trx; ++trx) { + llist_for_each_entry(trx, &bts->trx_list, list) { for (ts_no = 0; ts_no < 8; ++ts_no) { for (lchan_no = 0; lchan_no < TS_MAX_LCHAN; ++lchan_no) { struct gsm_lchan *lchan = - &bts->trx[trx].ts[ts_no].lchan[lchan_no]; + &trx->ts[ts_no].lchan[lchan_no]; if (subscr == lchan->subscr) return lchan; } diff --git a/openbsc/src/gsm_04_08.c b/openbsc/src/gsm_04_08.c index 49234f8d8..c081b45c2 100644 --- a/openbsc/src/gsm_04_08.c +++ b/openbsc/src/gsm_04_08.c @@ -3444,9 +3444,9 @@ int mncc_send(struct gsm_network *net, int msg_type, void *arg) trans->subscr = subscr; /* Find lchan */ for (i = 0; i < net->num_bts; i++) { - bts = &net->bts[i]; + bts = gsm_bts_num(net, i); for (j = 0; j < bts->num_trx; j++) { - trx = &bts->trx[j]; + trx = gsm_bts_trx_num(bts, j); for (k = 0; k < TRX_NR_TS; k++) { ts = &trx->ts[k]; for (l = 0; l < TS_MAX_LCHAN; l++) { diff --git a/openbsc/src/gsm_data.c b/openbsc/src/gsm_data.c index 80020e509..81facdf04 100644 --- a/openbsc/src/gsm_data.c +++ b/openbsc/src/gsm_data.c @@ -25,6 +25,7 @@ #include #include +#include void set_ts_e1link(struct gsm_bts_trx_ts *ts, u_int8_t e1_nr, u_int8_t e1_ts, u_int8_t e1_ts_ss) @@ -84,74 +85,122 @@ const char *gsm_chreq_name(enum gsm_chreq_reason_t c) return chreq_names[c]; } -struct gsm_network *gsm_network_init(unsigned int num_bts, enum gsm_bts_type bts_type, - u_int16_t country_code, u_int16_t network_code, - int (*mncc_recv)(struct gsm_network *, int, void *)) +struct gsm_bts_trx *gsm_bts_trx_alloc(struct gsm_bts *bts) { - int i; - struct gsm_network *net; + struct gsm_bts_trx *trx = talloc(bts, struct gsm_bts_trx); + int k; - if (num_bts > GSM_MAX_BTS) + if (!trx) return NULL; - net = malloc(sizeof(*net)); + memset(trx, 0, sizeof(*trx)); + trx->bts = bts; + trx->nr = bts->num_trx++; + + for (k = 0; k < TRX_NR_TS; k++) { + struct gsm_bts_trx_ts *ts = &trx->ts[k]; + int l; + + ts->trx = trx; + ts->nr = k; + ts->pchan = GSM_PCHAN_NONE; + + for (l = 0; l < TS_MAX_LCHAN; l++) { + struct gsm_lchan *lchan; + lchan = &ts->lchan[l]; + + lchan->ts = ts; + lchan->nr = l; + lchan->type = GSM_LCHAN_NONE; + } + } + + llist_add(&trx->list, &bts->trx_list); + + return trx; +} + +struct gsm_bts *gsm_bts_alloc(struct gsm_network *net, enum gsm_bts_type type, + u_int8_t tsc, u_int8_t bsic) +{ + struct gsm_bts *bts = talloc(net, struct gsm_bts); + + if (!bts) + return NULL; + + memset(bts, 0, sizeof(*bts)); + bts->network = net; + bts->nr = net->num_bts++; + bts->type = type; + bts->tsc = tsc; + bts->bsic = bsic; + bts->num_trx = 0; + INIT_LLIST_HEAD(&bts->trx_list); + + /* create our primary TRX */ + bts->c0 = gsm_bts_trx_alloc(bts); + if (!bts->c0) { + talloc_free(bts); + return NULL; + } + bts->c0->ts[0].pchan = GSM_PCHAN_CCCH_SDCCH4; + + llist_add(&bts->list, &net->bts_list); + + return bts; +} + +struct gsm_network *gsm_network_init(u_int16_t country_code, u_int16_t network_code, + int (*mncc_recv)(struct gsm_network *, int, void *)) +{ + struct gsm_network *net; + + net = talloc(tall_bsc_ctx, struct gsm_network); if (!net) return NULL; memset(net, 0, sizeof(*net)); net->country_code = country_code; net->network_code = network_code; - net->num_bts = num_bts; + net->num_bts = 0; INIT_LLIST_HEAD(&net->trans_list); INIT_LLIST_HEAD(&net->upqueue); + INIT_LLIST_HEAD(&net->bts_list); net->mncc_recv = mncc_recv; - for (i = 0; i < num_bts; i++) { - struct gsm_bts *bts = &net->bts[i]; - int j; - - bts->network = net; - bts->nr = i; - bts->type = bts_type; - bts->tsc = HARDCODED_TSC; - bts->bsic = HARDCODED_BSIC; - - for (j = 0; j < BTS_MAX_TRX; j++) { - struct gsm_bts_trx *trx = &bts->trx[j]; - int k; - - trx->bts = bts; - trx->nr = j; - - for (k = 0; k < TRX_NR_TS; k++) { - struct gsm_bts_trx_ts *ts = &trx->ts[k]; - int l; - - ts->trx = trx; - ts->nr = k; - ts->pchan = GSM_PCHAN_NONE; - - for (l = 0; l < TS_MAX_LCHAN; l++) { - struct gsm_lchan *lchan; - lchan = &ts->lchan[l]; - - lchan->ts = ts; - lchan->nr = l; - lchan->type = GSM_LCHAN_NONE; - } - } - } + return net; +} + +struct gsm_bts *gsm_bts_num(struct gsm_network *net, int num) +{ + struct gsm_bts *bts; + + if (num >= net->num_bts) + return NULL; + + llist_for_each_entry(bts, &net->bts_list, list) { + if (bts->nr == num) + return bts; + } + + return NULL; +} + +struct gsm_bts_trx *gsm_bts_trx_num(struct gsm_bts *bts, int num) +{ + struct gsm_bts_trx *trx; + + if (num >= bts->num_trx) + return NULL; - bts->num_trx = 1; /* FIXME */ -#ifdef HAVE_TRX1 - bts->num_trx++; -#endif - bts->c0 = &bts->trx[0]; - bts->c0->ts[0].pchan = GSM_PCHAN_CCCH_SDCCH4; + llist_for_each_entry(trx, &bts->trx_list, list) { + if (trx->nr == num) + return trx; } - return net; + + return NULL; } static char ts2str[255]; @@ -201,7 +250,7 @@ struct gsm_bts *gsm_bts_by_lac(struct gsm_network *net, unsigned int lac, skip = 1; for (i = 0; i < net->num_bts; i++) { - bts = &net->bts[i]; + bts = gsm_bts_num(net, i); if (skip) { if (start_bts == bts) diff --git a/openbsc/src/input/ipaccess.c b/openbsc/src/input/ipaccess.c index ccc178d17..c16bf1b60 100644 --- a/openbsc/src/input/ipaccess.c +++ b/openbsc/src/input/ipaccess.c @@ -112,10 +112,10 @@ static int ipac_idtag_parse(struct tlv_parsed *dec, unsigned char *buf, int len) struct gsm_bts *find_bts_by_unitid(struct gsm_network *net, u_int16_t site_id, u_int16_t bts_id) { + struct gsm_bts *bts; int i; - for (i = 0; i < net->num_bts; i++) { - struct gsm_bts *bts = &net->bts[i]; + llist_for_each_entry(bts, &net->bts_list, list) { if (!is_ipaccess_bts(bts)) continue; diff --git a/openbsc/src/ipaccess-config.c b/openbsc/src/ipaccess-config.c index cc8a6c9bc..d3f3176b3 100644 --- a/openbsc/src/ipaccess-config.c +++ b/openbsc/src/ipaccess-config.c @@ -170,11 +170,12 @@ int main(int argc, char **argv) exit(2); } - gsmnet = gsm_network_init(1, GSM_BTS_TYPE_NANOBTS_900, 1, 1, NULL); + gsmnet = gsm_network_init(1, 1, NULL); if (!gsmnet) exit(1); - bts = &gsmnet->bts[0]; + bts = gsm_bts_alloc(gsmnet, GSM_BTS_TYPE_NANOBTS_900, HARDCODED_TSC, + HARDCODED_BSIC); printf("Trying to connect to ip.access BTS ...\n"); diff --git a/openbsc/src/vty_interface.c b/openbsc/src/vty_interface.c index 1b6004631..12d5ae94a 100644 --- a/openbsc/src/vty_interface.c +++ b/openbsc/src/vty_interface.c @@ -147,12 +147,12 @@ DEFUN(show_bts, show_bts_cmd, "show bts [number]", VTY_NEWLINE); return CMD_WARNING; } - bts_dump_vty(vty, &net->bts[bts_nr]); + bts_dump_vty(vty, gsm_bts_num(net, bts_nr)); return CMD_SUCCESS; } /* print all BTS's */ for (bts_nr = 0; bts_nr < net->num_bts; bts_nr++) - bts_dump_vty(vty, &net->bts[bts_nr]); + bts_dump_vty(vty, gsm_bts_num(net, bts_nr)); return CMD_SUCCESS; } @@ -191,7 +191,7 @@ DEFUN(show_trx, VTY_NEWLINE); return CMD_WARNING; } - bts = &net->bts[bts_nr]; + bts = gsm_bts_num(net, bts_nr); } if (argc >= 2) { trx_nr = atoi(argv[1]); @@ -200,23 +200,23 @@ DEFUN(show_trx, VTY_NEWLINE); return CMD_WARNING; } - trx = &bts->trx[trx_nr]; + trx = gsm_bts_trx_num(bts, trx_nr); trx_dump_vty(vty, trx); return CMD_SUCCESS; } if (bts) { /* print all TRX in this BTS */ for (trx_nr = 0; trx_nr < bts->num_trx; trx_nr++) { - trx = &bts->trx[trx_nr]; + trx = gsm_bts_trx_num(bts, trx_nr); trx_dump_vty(vty, trx); } return CMD_SUCCESS; } for (bts_nr = 0; bts_nr < net->num_bts; bts_nr++) { - bts = &net->bts[bts_nr]; + bts = gsm_bts_num(net, bts_nr); for (trx_nr = 0; trx_nr < bts->num_trx; trx_nr++) { - trx = &bts->trx[trx_nr]; + trx = gsm_bts_trx_num(bts, trx_nr); trx_dump_vty(vty, trx); } } @@ -265,7 +265,7 @@ DEFUN(show_ts, VTY_NEWLINE); return CMD_WARNING; } - bts = &net->bts[bts_nr]; + bts = gsm_bts_num(net, bts_nr); } if (argc >= 2) { trx_nr = atoi(argv[1]); @@ -274,7 +274,7 @@ DEFUN(show_ts, VTY_NEWLINE); return CMD_WARNING; } - trx = &bts->trx[trx_nr]; + trx = gsm_bts_trx_num(bts, trx_nr); } if (argc >= 3) { ts_nr = atoi(argv[2]); @@ -288,9 +288,9 @@ DEFUN(show_ts, return CMD_SUCCESS; } for (bts_nr = 0; bts_nr < net->num_bts; bts_nr++) { - bts = &net->bts[bts_nr]; + bts = gsm_bts_num(net, bts_nr); for (trx_nr = 0; trx_nr < bts->num_trx; trx_nr++) { - trx = &bts->trx[trx_nr]; + trx = gsm_bts_trx_num(bts, trx_nr); for (ts_nr = 0; ts_nr < TRX_NR_TS; ts_nr++) { ts = &trx->ts[ts_nr]; ts_dump_vty(vty, ts); @@ -379,7 +379,7 @@ DEFUN(show_lchan, VTY_NEWLINE); return CMD_WARNING; } - bts = &net->bts[bts_nr]; + bts = gsm_bts_num(net, bts_nr); } if (argc >= 2) { trx_nr = atoi(argv[1]); @@ -388,7 +388,7 @@ DEFUN(show_lchan, VTY_NEWLINE); return CMD_WARNING; } - trx = &bts->trx[trx_nr]; + trx = gsm_bts_trx_num(bts, trx_nr); } if (argc >= 3) { ts_nr = atoi(argv[2]); @@ -411,9 +411,9 @@ DEFUN(show_lchan, return CMD_SUCCESS; } for (bts_nr = 0; bts_nr < net->num_bts; bts_nr++) { - bts = &net->bts[bts_nr]; + bts = gsm_bts_num(net, bts_nr); for (trx_nr = 0; trx_nr < bts->num_trx; trx_nr++) { - trx = &bts->trx[trx_nr]; + trx = gsm_bts_trx_num(bts, trx_nr); for (ts_nr = 0; ts_nr < TRX_NR_TS; ts_nr++) { ts = &trx->ts[ts_nr]; for (lchan_nr = 0; lchan_nr < TS_MAX_LCHAN; @@ -567,13 +567,13 @@ DEFUN(show_paging, VTY_NEWLINE); return CMD_WARNING; } - bts = &net->bts[bts_nr]; + bts = gsm_bts_num(net, bts_nr); bts_paging_dump_vty(vty, bts); return CMD_SUCCESS; } for (bts_nr = 0; bts_nr < net->num_bts; bts_nr++) { - bts = &net->bts[bts_nr]; + bts = gsm_bts_num(net, bts_nr); bts_paging_dump_vty(vty, bts); } @@ -612,14 +612,19 @@ DEFUN(cfg_bts, int bts_nr = atoi(argv[0]); struct gsm_bts *bts; - if (bts_nr >= GSM_MAX_BTS) { - vty_out(vty, "%% This Version of OpenBSC only supports %u BTS%s", - GSM_MAX_BTS, VTY_NEWLINE); + if (bts_nr > gsmnet->num_bts) { + vty_out(vty, "%% The next unused BTS number is %u%s", + gsmnet->num_bts, VTY_NEWLINE); + return CMD_WARNING; + } else if (bts_nr == gsmnet->num_bts) { + /* allocate a new one */ + bts = gsm_bts_alloc(gsmnet, GSM_BTS_TYPE_UNKNOWN, + HARDCODED_TSC, HARDCODED_BSIC); + } else + bts = gsm_bts_num(gsmnet, bts_nr); + + if (!bts) return CMD_WARNING; - } - bts = &gsmnet->bts[bts_nr]; - if (bts_nr >= gsmnet->num_bts) - gsmnet->num_bts = bts_nr + 1; vty->index = bts; vty->node = BTS_NODE; @@ -748,16 +753,18 @@ DEFUN(cfg_trx, struct gsm_bts *bts = vty->index; struct gsm_bts_trx *trx; - if (trx_nr > BTS_MAX_TRX) { - vty_out(vty, "%% This version of OpenBSC only supports %u TRX%s", - BTS_MAX_TRX+1, VTY_NEWLINE); + if (trx_nr > bts->num_trx) { + vty_out(vty, "%% The next unused TRX number in this BTS is %u%s", + bts->num_trx, VTY_NEWLINE); + return CMD_WARNING; + } else if (trx_nr == bts->num_trx) { + /* we need to allocate a new one */ + trx = gsm_bts_trx_alloc(bts); + } else + trx = gsm_bts_trx_num(bts, trx_nr); + + if (!trx) return CMD_WARNING; - } - - if (trx_nr >= bts->num_trx) - bts->num_trx = trx_nr+1; - - trx = &bts->trx[trx_nr]; vty->index = trx; vty->node = TRX_NODE; -- cgit v1.2.3 From a4ffea95057c98e532c897bde6cc06a575dec2c3 Mon Sep 17 00:00:00 2001 From: Harald Welte Date: Mon, 22 Jun 2009 01:36:25 +0200 Subject: fix various talloc / dynamic bts/trx related bugs Prior to this patch, nanobts was not able to operate after recent changes --- openbsc/src/input/ipaccess.c | 16 ++++++++++++---- openbsc/src/telnet_interface.c | 2 +- 2 files changed, 13 insertions(+), 5 deletions(-) (limited to 'openbsc') diff --git a/openbsc/src/input/ipaccess.c b/openbsc/src/input/ipaccess.c index c16bf1b60..b76629e5e 100644 --- a/openbsc/src/input/ipaccess.c +++ b/openbsc/src/input/ipaccess.c @@ -223,7 +223,7 @@ static int ipaccess_rcvmsg(struct e1inp_line *line, struct msgb *msg, memcpy(newbfd, bfd, sizeof(*newbfd)); bsc_unregister_fd(bfd); bsc_register_fd(newbfd); - free(bfd); + talloc_free(bfd); } break; case IPAC_MSGT_ID_ACK: @@ -454,7 +454,7 @@ static int listen_fd_cb(struct bsc_fd *listen_bfd, unsigned int what) if (ret < 0) { fprintf(stderr, "could not register FD\n"); close(bfd->fd); - free(line); + talloc_free(line); return ret; } @@ -468,12 +468,17 @@ static int rsl_listen_fd_cb(struct bsc_fd *listen_bfd, unsigned int what) { struct sockaddr_in sa; socklen_t sa_len = sizeof(sa); - struct bsc_fd *bfd = talloc(tall_bsc_ctx, struct bsc_fd); + struct bsc_fd *bfd; int ret; if (!(what & BSC_FD_READ)) return 0; + bfd = talloc(tall_bsc_ctx, struct bsc_fd); + if (!bfd) + return -ENOMEM; + memset(bfd, 0, sizeof(*bfd)); + /* Some BTS has connected to us, but we don't know yet which line * (as created by the OML link) to associate it with. Thus, we * aloocate a temporary bfd until we have received ID from BTS */ @@ -491,7 +496,7 @@ static int rsl_listen_fd_cb(struct bsc_fd *listen_bfd, unsigned int what) if (ret < 0) { fprintf(stderr, "could not register FD\n"); close(bfd->fd); - free(bfd); + talloc_free(bfd); return ret; } /* Request ID. FIXME: request LOCATION, HW/SW VErsion, Unit Name, Serno */ @@ -583,7 +588,10 @@ int ipaccess_setup(struct gsm_network *gsmnet) return ret; e1h = talloc(tall_bsc_ctx, struct ia_e1_handle); + if (!e1h) + return -ENOMEM; memset(e1h, 0, sizeof(*e1h)); + e1h->gsmnet = gsmnet; /* Listen for OML connections */ diff --git a/openbsc/src/telnet_interface.c b/openbsc/src/telnet_interface.c index 8b9fd7983..5cc6ea0af 100644 --- a/openbsc/src/telnet_interface.c +++ b/openbsc/src/telnet_interface.c @@ -132,7 +132,7 @@ int telnet_close_client(struct bsc_fd *fd) { close(fd->fd); bsc_unregister_fd(fd); llist_del(&conn->entry); - free(conn); + talloc_free(conn); return 0; } -- cgit v1.2.3 From fe9af26c3ed8f281e39be912a3bfa1e0b3f7c675 Mon Sep 17 00:00:00 2001 From: Harald Welte Date: Sat, 20 Jun 2009 18:44:35 +0200 Subject: Add parsing of 'L1 information' IE of MEASUREMENT RESULT --- openbsc/src/abis_rsl.c | 45 +++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 43 insertions(+), 2 deletions(-) (limited to 'openbsc') diff --git a/openbsc/src/abis_rsl.c b/openbsc/src/abis_rsl.c index 5c1967d38..b8990c7ee 100644 --- a/openbsc/src/abis_rsl.c +++ b/openbsc/src/abis_rsl.c @@ -418,6 +418,41 @@ static int ms_pwr_ctl_lvl(struct gsm_bts *bts, unsigned int dbm) return -EINVAL; } +static int ms_pwr_dbm(enum gsm_band band, u_int8_t lvl) +{ + lvl &= 0x1f; + + switch (band) { + case GSM_BAND_400: + case GSM_BAND_900: + case GSM_BAND_850: + if (lvl < 2) + return 39; + else if (lvl < 20) + return 39 - ((lvl - 2) * 2) ; + else + return 5; + break; + case GSM_BAND_1800: + if (lvl < 16) + return 30 - (lvl * 2); + else if (lvl < 29) + return 0; + else + return 36 - ((lvl - 29) * 2); + break; + case GSM_BAND_1900: + if (lvl < 16) + return 30 - (lvl * 2); + else if (lvl < 30) + return -EINVAL; + else + return 33 - (lvl - 30); + break; + } + return -EINVAL; +} + int rsl_chan_ms_power_ctrl(struct gsm_lchan *lchan, unsigned int fpc, int dbm) { struct abis_rsl_dchan_hdr *dh; @@ -809,8 +844,14 @@ static int rsl_rx_meas_res(struct msgb *msg) if (TLVP_PRESENT(&tp, RSL_IE_MS_TIMING_OFFSET)) DEBUGPC(DRSL, "MS_TO=%d ", *TLVP_VAL(&tp, RSL_IE_MS_TIMING_OFFSET)); - if (TLVP_PRESENT(&tp, RSL_IE_L1_INFO)) - DEBUGPC(DRSL, "L1 "); + if (TLVP_PRESENT(&tp, RSL_IE_L1_INFO)) { + u_int8_t *val = TLVP_VAL(&tp, RSL_IE_L1_INFO); + u_int8_t pwr_lvl = val[0] >> 3; + DEBUGPC(DRSL, "L1_MS_PWR=%ddBm ", + ms_pwr_dbm(msg->trx->bts->band, pwr_lvl)); + DEBUGPC(DRSL, "L1_FPC=%u ", val[0] & 0x04 ? 1 : 0); + DEBUGPC(DRSL, "L1_TA=%u ", val[1]); + } if (TLVP_PRESENT(&tp, RSL_IE_L3_INFO)) { DEBUGPC(DRSL, "L3\n"); msg->l3h = TLVP_VAL(&tp, RSL_IE_L3_INFO); -- cgit v1.2.3 From 966636f39f17e5d42e7918a2055d400c791671b4 Mon Sep 17 00:00:00 2001 From: Harald Welte Date: Fri, 26 Jun 2009 19:39:35 +0200 Subject: use named variant when allocating msgb's when we generate a talloc report (SIGUSR1), we can now see which system allocated a given msgb, this helps memory leak debugging --- openbsc/include/openbsc/msgb.h | 7 ++++--- openbsc/src/abis_nm.c | 3 ++- openbsc/src/abis_rsl.c | 3 ++- openbsc/src/e1_input.c | 2 +- openbsc/src/gsm_04_08.c | 5 +++-- openbsc/src/gsm_04_11.c | 3 ++- openbsc/src/input/ipaccess.c | 2 +- openbsc/src/input/misdn.c | 4 ++-- openbsc/src/msgb.c | 5 ++--- openbsc/src/rs232.c | 2 +- openbsc/src/trau_mux.c | 3 ++- 11 files changed, 22 insertions(+), 17 deletions(-) (limited to 'openbsc') diff --git a/openbsc/include/openbsc/msgb.h b/openbsc/include/openbsc/msgb.h index 2c31d1587..5ecac459b 100644 --- a/openbsc/include/openbsc/msgb.h +++ b/openbsc/include/openbsc/msgb.h @@ -47,7 +47,7 @@ struct msgb { unsigned char _data[0]; }; -extern struct msgb *msgb_alloc(u_int16_t size); +extern struct msgb *msgb_alloc(u_int16_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); @@ -100,9 +100,10 @@ static inline void msgb_reserve(struct msgb *msg, int len) msg->tail += len; } -static inline struct msgb *msgb_alloc_headroom(int size, int headroom) +static inline struct msgb *msgb_alloc_headroom(int size, int headroom, + const char *name) { - struct msgb *msg = msgb_alloc(size); + struct msgb *msg = msgb_alloc(size, name); if (msg) msgb_reserve(msg, headroom); return msg; diff --git a/openbsc/src/abis_nm.c b/openbsc/src/abis_nm.c index 6b1fc54f7..4a73930fc 100644 --- a/openbsc/src/abis_nm.c +++ b/openbsc/src/abis_nm.c @@ -423,7 +423,8 @@ static void fill_om_fom_hdr(struct abis_om_hdr *oh, u_int8_t len, static struct msgb *nm_msgb_alloc(void) { - return msgb_alloc_headroom(OM_ALLOC_SIZE, OM_HEADROOM_SIZE); + return msgb_alloc_headroom(OM_ALLOC_SIZE, OM_HEADROOM_SIZE, + "OML"); } /* Send a OML NM Message from BSC to BTS */ diff --git a/openbsc/src/abis_rsl.c b/openbsc/src/abis_rsl.c index b8990c7ee..0488b9dfe 100644 --- a/openbsc/src/abis_rsl.c +++ b/openbsc/src/abis_rsl.c @@ -293,7 +293,8 @@ unsigned int get_paging_group(u_int64_t imsi, unsigned int bs_cc_chans, static struct msgb *rsl_msgb_alloc(void) { - return msgb_alloc_headroom(RSL_ALLOC_SIZE, RSL_ALLOC_HEADROOM); + return msgb_alloc_headroom(RSL_ALLOC_SIZE, RSL_ALLOC_HEADROOM, + "RSL"); } #define MACBLOCK_SIZE 23 diff --git a/openbsc/src/e1_input.c b/openbsc/src/e1_input.c index 84dde9047..9de6b0141 100644 --- a/openbsc/src/e1_input.c +++ b/openbsc/src/e1_input.c @@ -458,7 +458,7 @@ struct msgb *e1inp_tx_ts(struct e1inp_ts *e1i_ts, } break; case E1INP_TS_TYPE_TRAU: - msg = msgb_alloc(TSX_ALLOC_SIZE); + msg = msgb_alloc(TSX_ALLOC_SIZE, "TRAU_TX"); if (!msg) return NULL; len = subchan_mux_out(&e1i_ts->trau.mux, msg->data, 40); diff --git a/openbsc/src/gsm_04_08.c b/openbsc/src/gsm_04_08.c index c081b45c2..56db65439 100644 --- a/openbsc/src/gsm_04_08.c +++ b/openbsc/src/gsm_04_08.c @@ -975,7 +975,8 @@ static int encode_more(struct msgb *msg) struct msgb *gsm48_msgb_alloc(void) { - return msgb_alloc_headroom(GSM48_ALLOC_SIZE, GSM48_ALLOC_HEADROOM); + return msgb_alloc_headroom(GSM48_ALLOC_SIZE, GSM48_ALLOC_HEADROOM, + "GSM 04.08"); } int gsm48_sendmsg(struct msgb *msg) @@ -1856,7 +1857,7 @@ static int mncc_recvmsg(struct gsm_network *net, struct gsm_trans *trans, mncc->msg_type = msg_type; - msg = msgb_alloc(sizeof(struct gsm_mncc)); + msg = msgb_alloc(sizeof(struct gsm_mncc), "MNCC"); if (!msg) return -ENOMEM; memcpy(msg->data, mncc, sizeof(struct gsm_mncc)); diff --git a/openbsc/src/gsm_04_11.c b/openbsc/src/gsm_04_11.c index 571da4cba..1b622b12b 100644 --- a/openbsc/src/gsm_04_11.c +++ b/openbsc/src/gsm_04_11.c @@ -51,7 +51,8 @@ static void *tall_gsms_ctx; struct msgb *gsm411_msgb_alloc(void) { - return msgb_alloc_headroom(GSM411_ALLOC_SIZE, GSM411_ALLOC_HEADROOM); + return msgb_alloc_headroom(GSM411_ALLOC_SIZE, GSM411_ALLOC_HEADROOM, + "GSM 04.11"); } int gsm0411_sendmsg(struct msgb *msg) diff --git a/openbsc/src/input/ipaccess.c b/openbsc/src/input/ipaccess.c index b76629e5e..cee53cc13 100644 --- a/openbsc/src/input/ipaccess.c +++ b/openbsc/src/input/ipaccess.c @@ -244,7 +244,7 @@ static int handle_ts1_read(struct bsc_fd *bfd) unsigned int ts_nr = bfd->priv_nr; struct e1inp_ts *e1i_ts = &line->ts[ts_nr-1]; struct e1inp_sign_link *link; - struct msgb *msg = msgb_alloc(TS1_ALLOC_SIZE); + struct msgb *msg = msgb_alloc(TS1_ALLOC_SIZE, "Abis/IP"); struct ipaccess_head *hh; int ret; diff --git a/openbsc/src/input/misdn.c b/openbsc/src/input/misdn.c index 44f09646d..367d8e4a6 100644 --- a/openbsc/src/input/misdn.c +++ b/openbsc/src/input/misdn.c @@ -96,7 +96,7 @@ static int handle_ts1_read(struct bsc_fd *bfd) unsigned int ts_nr = bfd->priv_nr; struct e1inp_ts *e1i_ts = &line->ts[ts_nr-1]; struct e1inp_sign_link *link; - struct msgb *msg = msgb_alloc(TS1_ALLOC_SIZE); + struct msgb *msg = msgb_alloc(TS1_ALLOC_SIZE, "mISDN TS1"); struct sockaddr_mISDN l2addr; struct mISDNhead *hh; socklen_t alen; @@ -278,7 +278,7 @@ static int handle_tsX_read(struct bsc_fd *bfd) struct e1inp_line *line = bfd->data; unsigned int ts_nr = bfd->priv_nr; struct e1inp_ts *e1i_ts = &line->ts[ts_nr-1]; - struct msgb *msg = msgb_alloc(TSX_ALLOC_SIZE); + struct msgb *msg = msgb_alloc(TSX_ALLOC_SIZE, "mISDN TSx"); struct mISDNhead *hh; int ret; diff --git a/openbsc/src/msgb.c b/openbsc/src/msgb.c index 8bdc9aa70..ae1334614 100644 --- a/openbsc/src/msgb.c +++ b/openbsc/src/msgb.c @@ -29,18 +29,17 @@ static void *tall_msgb_ctx; -struct msgb *msgb_alloc(u_int16_t size) +struct msgb *msgb_alloc(u_int16_t size, const char *name) { struct msgb *msg; if (!tall_msgb_ctx) tall_msgb_ctx = talloc_named_const(tall_bsc_ctx, 1, "msgb"); - msg = talloc_size(tall_msgb_ctx, sizeof(*msg) + size); + msg = _talloc_zero(tall_msgb_ctx, sizeof(*msg) + size, name); if (!msg) return NULL; - memset(msg, 0, sizeof(*msg)+size); msg->data_len = size; msg->len = 0; diff --git a/openbsc/src/rs232.c b/openbsc/src/rs232.c index 2a64de5ef..a58472364 100644 --- a/openbsc/src/rs232.c +++ b/openbsc/src/rs232.c @@ -127,7 +127,7 @@ static int handle_ser_read(struct bsc_fd *bfd) int rc = 0; if (!sh->rx_msg) { - sh->rx_msg = msgb_alloc(SERIAL_ALLOC_SIZE); + sh->rx_msg = msgb_alloc(SERIAL_ALLOC_SIZE, "RS232 Rx"); sh->rx_msg->l2h = NULL; sh->rx_msg->trx = sh->bts->c0; } diff --git a/openbsc/src/trau_mux.c b/openbsc/src/trau_mux.c index 7615b6294..04febbd63 100644 --- a/openbsc/src/trau_mux.c +++ b/openbsc/src/trau_mux.c @@ -170,7 +170,8 @@ int trau_mux_input(struct gsm_e1_subslot *src_e1_ss, return -EINVAL; if (!ue->callref) return -EINVAL; - msg = msgb_alloc(sizeof(struct gsm_trau_frame) + sizeof(tf)); + msg = msgb_alloc(sizeof(struct gsm_trau_frame) + sizeof(tf), + "TRAU"); if (!msg) return -ENOMEM; frame = (struct gsm_trau_frame *)msg->data; -- cgit v1.2.3 From 316c825fcd477b81b1ba9185d1edfc730b165377 Mon Sep 17 00:00:00 2001 From: Harald Welte Date: Fri, 26 Jun 2009 19:40:48 +0200 Subject: fix MNCC memory leak after passing the mncc structure (contained in msgb) to the mncc layer, we have to release its memory. This leak was discovered as a direct result of using talloc. --- openbsc/src/gsm_04_08.c | 1 + 1 file changed, 1 insertion(+) (limited to 'openbsc') diff --git a/openbsc/src/gsm_04_08.c b/openbsc/src/gsm_04_08.c index 56db65439..c77268e26 100644 --- a/openbsc/src/gsm_04_08.c +++ b/openbsc/src/gsm_04_08.c @@ -3809,6 +3809,7 @@ int bsc_upqueue(struct gsm_network *net) if (net->mncc_recv) net->mncc_recv(net, mncc->msg_type, mncc); work = 1; /* work done */ + talloc_free(msg); } return work; -- cgit v1.2.3 From 678bdeac1f1b5983cb88f1d8fa3ee87a34324f4b Mon Sep 17 00:00:00 2001 From: Harald Welte Date: Fri, 26 Jun 2009 19:42:14 +0200 Subject: add FIXME about memory leak every time we close telnet --- openbsc/src/vty/vty.c | 3 +++ 1 file changed, 3 insertions(+) (limited to 'openbsc') diff --git a/openbsc/src/vty/vty.c b/openbsc/src/vty/vty.c index ca6fff73c..c46163193 100644 --- a/openbsc/src/vty/vty.c +++ b/openbsc/src/vty/vty.c @@ -161,6 +161,9 @@ void vty_close(struct vty *vty) /* OK free vty. */ free(vty); + + /* FIXME: memory leak. We need to call telnet_close_client() but don't + * have bfd */ } int vty_shell(struct vty *vty) -- cgit v1.2.3 From 9b11e8741d25637b343c8aa8613e69ba7c02d1e4 Mon Sep 17 00:00:00 2001 From: Harald Welte Date: Fri, 26 Jun 2009 19:42:28 +0200 Subject: zero-initialize some more memory that we allocate --- openbsc/src/gsm_04_08.c | 2 +- openbsc/src/mncc.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) (limited to 'openbsc') diff --git a/openbsc/src/gsm_04_08.c b/openbsc/src/gsm_04_08.c index c77268e26..76d748c05 100644 --- a/openbsc/src/gsm_04_08.c +++ b/openbsc/src/gsm_04_08.c @@ -3634,7 +3634,7 @@ static int gsm0408_rcv_cc(struct msgb *msg) DEBUGP(DCC, "Unknown transaction ID %02x, " "creating new trans.\n", transaction_id); /* Create transaction */ - if (!(trans = talloc(tall_trans_ctx, struct gsm_trans))) { + if (!(trans = talloc_zero(tall_trans_ctx, struct gsm_trans))) { DEBUGP(DCC, "No memory for trans.\n"); rc = gsm48_tx_simple(msg->lchan, GSM48_PDISC_CC | transaction_id, diff --git a/openbsc/src/mncc.c b/openbsc/src/mncc.c index 71f2ad501..b2dab078e 100644 --- a/openbsc/src/mncc.c +++ b/openbsc/src/mncc.c @@ -310,7 +310,7 @@ int mncc_recv(struct gsm_network *net, int msg_type, void *arg) tall_call_ctx = talloc_named_const(tall_bsc_ctx, 1, "gsm_call"); /* create call */ - if (!(call = talloc(tall_call_ctx, struct gsm_call))) { + if (!(call = talloc_zero(tall_call_ctx, struct gsm_call))) { struct gsm_mncc rel; memset(&rel, 0, sizeof(struct gsm_mncc)); -- cgit v1.2.3 From c05677b036dce4dbf59414dc15b75a5b3472ae6e Mon Sep 17 00:00:00 2001 From: Harald Welte Date: Fri, 26 Jun 2009 20:17:06 +0200 Subject: fix two segfaults * when paging callback is called, we need to consider a failed paging operation (i.e. lchan == NULL) * we have to zero-initialize every transaction that is allocated --- openbsc/src/gsm_04_08.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) (limited to 'openbsc') diff --git a/openbsc/src/gsm_04_08.c b/openbsc/src/gsm_04_08.c index 76d748c05..d6f131e23 100644 --- a/openbsc/src/gsm_04_08.c +++ b/openbsc/src/gsm_04_08.c @@ -387,6 +387,9 @@ static int gsm0408_handle_lchan_signal(unsigned int subsys, unsigned int signal, * operation taking place on the lchan. */ struct gsm_lchan *lchan = (struct gsm_lchan *)handler_data; + if (!lchan) + return 0; + release_loc_updating_req(lchan); /* Free all transactions that are associated with the released lchan */ @@ -1932,7 +1935,7 @@ static int setup_trig_pag_evt(unsigned int hooknum, unsigned int event, struct gsm_subscriber *subscr = param; struct gsm_trans *transt, *tmp; struct gsm_network *net; - + if (hooknum != GSM_HOOK_RR_PAGING) return -EINVAL; @@ -3428,7 +3431,7 @@ int mncc_send(struct gsm_network *net, int msg_type, void *arg) GSM48_CC_CAUSE_DEST_OOO); } /* Create transaction */ - if (!(trans = talloc(tall_trans_ctx, struct gsm_trans))) { + if (!(trans = talloc_zero(tall_trans_ctx, struct gsm_trans))) { DEBUGP(DCC, "No memory for trans.\n"); subscr_put(subscr); /* Ressource unavailable */ -- cgit v1.2.3 From 470ec29b0db526c1592f6a270652657315efddca Mon Sep 17 00:00:00 2001 From: Harald Welte Date: Fri, 26 Jun 2009 20:25:23 +0200 Subject: use taloc_zero() rather than talloc() and explisit memset() --- openbsc/src/abis_nm.c | 3 +-- openbsc/src/e1_config.c | 6 ++---- openbsc/src/e1_input.c | 4 +--- openbsc/src/gsm_04_08.c | 5 ++--- openbsc/src/paging.c | 3 +-- openbsc/src/subchan_demux.c | 5 ++--- openbsc/src/telnet_interface.c | 3 +-- 7 files changed, 10 insertions(+), 19 deletions(-) (limited to 'openbsc') diff --git a/openbsc/src/abis_nm.c b/openbsc/src/abis_nm.c index 4a73930fc..b07aa3116 100644 --- a/openbsc/src/abis_nm.c +++ b/openbsc/src/abis_nm.c @@ -2079,12 +2079,11 @@ static int bs11_read_swl_file(struct abis_nm_bs11_sw *bs11_sw) if (rc < 2) continue; - fle = talloc(tall_fle_ctx, struct file_list_entry); + fle = talloc_zero(tall_fle_ctx, struct file_list_entry); if (!fle) { rc = -ENOMEM; goto out; } - memset(fle, 0, sizeof(*fle)); /* construct new filename */ strncpy(dir, bs11_sw->swl_fname, sizeof(dir)); diff --git a/openbsc/src/e1_config.c b/openbsc/src/e1_config.c index abc30402f..9c9f40cff 100644 --- a/openbsc/src/e1_config.c +++ b/openbsc/src/e1_config.c @@ -25,10 +25,9 @@ int e1_config(struct gsm_bts *bts, int cardnr, int release_l2) struct e1inp_ts *sign_ts; struct e1inp_sign_link *oml_link, *rsl_link; - line = talloc(tall_bsc_ctx, struct e1inp_line); + line = talloc_zero(tall_bsc_ctx, struct e1inp_line); if (!line) return -ENOMEM; - memset(line, 0, sizeof(*line)); /* create E1 timeslots for signalling and TRAU frames */ e1inp_ts_config(&line->ts[1-1], line, E1INP_TS_TYPE_SIGN); @@ -80,10 +79,9 @@ int ia_config_connect(struct gsm_bts *bts, struct sockaddr_in *sin) struct e1inp_ts *sign_ts, *rsl_ts; struct e1inp_sign_link *oml_link, *rsl_link; - line = talloc(tall_bsc_ctx, struct e1inp_line); + line = talloc_zero(tall_bsc_ctx, struct e1inp_line); if (!line) return -ENOMEM; - memset(line, 0, sizeof(*line)); /* create E1 timeslots for signalling and TRAU frames */ e1inp_ts_config(&line->ts[1-1], line, E1INP_TS_TYPE_SIGN); diff --git a/openbsc/src/e1_input.c b/openbsc/src/e1_input.c index 9de6b0141..56bce019c 100644 --- a/openbsc/src/e1_input.c +++ b/openbsc/src/e1_input.c @@ -373,12 +373,10 @@ e1inp_sign_link_create(struct e1inp_ts *ts, enum e1inp_sign_type type, tall_sigl_ctx = talloc_named_const(tall_bsc_ctx, 1, "e1inp_sign_link"); - link = talloc(tall_sigl_ctx, struct e1inp_sign_link); + link = talloc_zero(tall_sigl_ctx, struct e1inp_sign_link); if (!link) return NULL; - memset(link, 0, sizeof(*link)); - link->ts = ts; link->type = type; INIT_LLIST_HEAD(&link->tx_list); diff --git a/openbsc/src/gsm_04_08.c b/openbsc/src/gsm_04_08.c index d6f131e23..6d8530bcb 100644 --- a/openbsc/src/gsm_04_08.c +++ b/openbsc/src/gsm_04_08.c @@ -354,9 +354,8 @@ static void allocate_loc_updating_req(struct gsm_lchan *lchan) if (!tall_locop_ctx) tall_locop_ctx = talloc_named_const(tall_bsc_ctx, 1, "loc_updating_oper"); - lchan->loc_operation = talloc(tall_locop_ctx, - struct gsm_loc_updating_operation); - memset(lchan->loc_operation, 0, sizeof(*lchan->loc_operation)); + lchan->loc_operation = talloc_zero(tall_locop_ctx, + struct gsm_loc_updating_operation); } static int gsm0408_authorize(struct gsm_lchan *lchan, struct msgb *msg) diff --git a/openbsc/src/paging.c b/openbsc/src/paging.c index 217da7e0a..0703e932f 100644 --- a/openbsc/src/paging.c +++ b/openbsc/src/paging.c @@ -228,8 +228,7 @@ static void _paging_request(struct gsm_bts *bts, struct gsm_subscriber *subscr, } DEBUGP(DPAG, "Start paging on bts %d.\n", bts->nr); - req = talloc(tall_paging_ctx, struct gsm_paging_request); - memset(req, 0, sizeof(*req)); + req = talloc_zero(tall_paging_ctx, struct gsm_paging_request); req->subscr = subscr_get(subscr); req->bts = bts; req->chan_type = type; diff --git a/openbsc/src/subchan_demux.c b/openbsc/src/subchan_demux.c index 56f3dd3f2..ccd4fadc6 100644 --- a/openbsc/src/subchan_demux.c +++ b/openbsc/src/subchan_demux.c @@ -291,12 +291,11 @@ int subchan_mux_enqueue(struct subch_mux *mx, int s_nr, const u_int8_t *data, { struct mux_subch *sch = &mx->subch[s_nr]; int list_len = llist_len(&sch->tx_queue); - struct subch_txq_entry *tqe = talloc_size(tall_tqe_ctx, - sizeof(*tqe) + len); + struct subch_txq_entry *tqe = talloc_zero_size(tall_tqe_ctx, + sizeof(*tqe) + len); if (!tqe) return -ENOMEM; - memset(tqe, 0, sizeof(*tqe)); tqe->bit_len = len; memcpy(tqe->bits, data, len); diff --git a/openbsc/src/telnet_interface.c b/openbsc/src/telnet_interface.c index 5cc6ea0af..7a67fe1de 100644 --- a/openbsc/src/telnet_interface.c +++ b/openbsc/src/telnet_interface.c @@ -167,8 +167,7 @@ static int telnet_new_connection(struct bsc_fd *fd, unsigned int what) { } - connection = talloc(tall_telnet_ctx, struct telnet_connection); - memset(connection, 0, sizeof(*connection)); + connection = talloc_zero(tall_telnet_ctx, struct telnet_connection); connection->network = (struct gsm_network*)fd->data; connection->fd.data = connection; connection->fd.fd = new_connection; -- cgit v1.2.3 From 6bfda782b9cc30b5c10ad0290949c6d25d4c83cf Mon Sep 17 00:00:00 2001 From: Harald Welte Date: Fri, 26 Jun 2009 20:30:46 +0200 Subject: make tests compile again after talloc branch changes --- openbsc/tests/channel/Makefile.am | 1 + openbsc/tests/channel/channel_test.c | 13 +++++++++---- openbsc/tests/sms/sms_test.c | 2 +- 3 files changed, 11 insertions(+), 5 deletions(-) (limited to 'openbsc') diff --git a/openbsc/tests/channel/Makefile.am b/openbsc/tests/channel/Makefile.am index 60defe0a6..5a3477cf5 100644 --- a/openbsc/tests/channel/Makefile.am +++ b/openbsc/tests/channel/Makefile.am @@ -9,6 +9,7 @@ channel_test_SOURCES = channel_test.c \ $(top_srcdir)/src/debug.c \ $(top_srcdir)/src/timer.c \ $(top_srcdir)/src/select.c \ + $(top_srcdir)/src/talloc.c \ $(top_srcdir)/src/gsm_data.c channel_test_LDADD = -ldl -ldbi diff --git a/openbsc/tests/channel/channel_test.c b/openbsc/tests/channel/channel_test.c index 1787e358c..ab165c720 100644 --- a/openbsc/tests/channel/channel_test.c +++ b/openbsc/tests/channel/channel_test.c @@ -19,6 +19,7 @@ */ #include +#include #include @@ -47,20 +48,24 @@ void paging_request(struct gsm_bts *bts, struct gsm_subscriber *subscriber, int int main(int argc, char** argv) { - struct gsm_network network; + struct gsm_network *network; + struct gsm_bts *bts; printf("Testing the gsm_subscriber chan logic\n"); /* Create a dummy network */ - network.bts[0].location_area_code = 23; - network.bts[0].network = &network; + network = gsm_network_init(1, 1, NULL); + if (!network) + exit(1); + bts = gsm_bts_alloc(network, GSM_BTS_TYPE_BS11, 0, 0); + bts->location_area_code = 23; /* Create a dummy subscriber */ struct gsm_subscriber *subscr = subscr_alloc(); subscr->lac = 23; /* Ask for a channel... */ - subscr_get_channel(subscr, &network, RSL_CHANNEED_TCH_F, subscr_cb, (void*)0x2342L); + subscr_get_channel(subscr, network, RSL_CHANNEED_TCH_F, subscr_cb, (void*)0x2342L); while (1) { bsc_select_main(0); diff --git a/openbsc/tests/sms/sms_test.c b/openbsc/tests/sms/sms_test.c index dfc43cf70..5c3c7c7fc 100644 --- a/openbsc/tests/sms/sms_test.c +++ b/openbsc/tests/sms/sms_test.c @@ -92,7 +92,7 @@ int main(int argc, char** argv) for(i=0;i Date: Sat, 27 Jun 2009 02:53:10 +0200 Subject: add new DMEAS debug category for measurement reporting disable it by default --- openbsc/include/openbsc/debug.h | 1 + openbsc/src/abis_rsl.c | 27 ++++++++++++++------------- openbsc/src/debug.c | 3 ++- openbsc/src/gsm_04_08.c | 12 ++++++------ 4 files changed, 23 insertions(+), 20 deletions(-) (limited to 'openbsc') diff --git a/openbsc/include/openbsc/debug.h b/openbsc/include/openbsc/debug.h index 63f9e671c..f99ce6081 100644 --- a/openbsc/include/openbsc/debug.h +++ b/openbsc/include/openbsc/debug.h @@ -13,6 +13,7 @@ #define DMNCC 0x0080 #define DSMS 0x0100 #define DPAG 0x0200 +#define DMEAS 0x0400 #define DMI 0x1000 #define DMIB 0x2000 diff --git a/openbsc/src/abis_rsl.c b/openbsc/src/abis_rsl.c index 0488b9dfe..397d793c7 100644 --- a/openbsc/src/abis_rsl.c +++ b/openbsc/src/abis_rsl.c @@ -823,42 +823,42 @@ static int rsl_rx_meas_res(struct msgb *msg) struct abis_rsl_dchan_hdr *dh = msgb_l2(msg); struct tlv_parsed tp; - DEBUGPC(DRSL, "MEASUREMENT RESULT "); + DEBUGPC(DMEAS, "MEASUREMENT RESULT "); rsl_tlv_parse(&tp, dh->data, msgb_l2len(msg)-sizeof(*dh)); if (TLVP_PRESENT(&tp, RSL_IE_MEAS_RES_NR)) - DEBUGPC(DRSL, "NR=%d ", *TLVP_VAL(&tp, RSL_IE_MEAS_RES_NR)); + DEBUGPC(DMEAS, "NR=%d ", *TLVP_VAL(&tp, RSL_IE_MEAS_RES_NR)); if (TLVP_PRESENT(&tp, RSL_IE_UPLINK_MEAS)) { u_int8_t len = TLVP_LEN(&tp, RSL_IE_UPLINK_MEAS); const u_int8_t *val = TLVP_VAL(&tp, RSL_IE_UPLINK_MEAS); if (len >= 3) { if (val[0] & 0x40) - DEBUGPC(DRSL, "DTXd "); - DEBUGPC(DRSL, "RXL-FULL-up=%d RXL-SUB-up=%d ", + DEBUGPC(DMEAS, "DTXd "); + DEBUGPC(DMEAS, "RXL-FULL-up=%d RXL-SUB-up=%d ", val[0] & 0x3f, val[1] & 0x3f); - DEBUGPC(DRSL, "RXQ-FULL-up=%d RXQ-SUB-up=%d ", + DEBUGPC(DMEAS, "RXQ-FULL-up=%d RXQ-SUB-up=%d ", val[2]>>3 & 0x7, val[2] & 0x7); } } if (TLVP_PRESENT(&tp, RSL_IE_BS_POWER)) - DEBUGPC(DRSL, "BS_POWER=%d ", *TLVP_VAL(&tp, RSL_IE_BS_POWER)); + DEBUGPC(DMEAS, "BS_POWER=%d ", *TLVP_VAL(&tp, RSL_IE_BS_POWER)); if (TLVP_PRESENT(&tp, RSL_IE_MS_TIMING_OFFSET)) - DEBUGPC(DRSL, "MS_TO=%d ", + DEBUGPC(DMEAS, "MS_TO=%d ", *TLVP_VAL(&tp, RSL_IE_MS_TIMING_OFFSET)); if (TLVP_PRESENT(&tp, RSL_IE_L1_INFO)) { u_int8_t *val = TLVP_VAL(&tp, RSL_IE_L1_INFO); u_int8_t pwr_lvl = val[0] >> 3; - DEBUGPC(DRSL, "L1_MS_PWR=%ddBm ", + DEBUGPC(DMEAS, "L1_MS_PWR=%ddBm ", ms_pwr_dbm(msg->trx->bts->band, pwr_lvl)); - DEBUGPC(DRSL, "L1_FPC=%u ", val[0] & 0x04 ? 1 : 0); - DEBUGPC(DRSL, "L1_TA=%u ", val[1]); + DEBUGPC(DMEAS, "L1_FPC=%u ", val[0] & 0x04 ? 1 : 0); + DEBUGPC(DMEAS, "L1_TA=%u ", val[1]); } if (TLVP_PRESENT(&tp, RSL_IE_L3_INFO)) { - DEBUGPC(DRSL, "L3\n"); + DEBUGPC(DMEAS, "L3\n"); msg->l3h = TLVP_VAL(&tp, RSL_IE_L3_INFO); return gsm0408_rcvmsg(msg); } else - DEBUGPC(DRSL, "\n"); + DEBUGPC(DMEAS, "\n"); return 0; } @@ -872,7 +872,8 @@ static int abis_rsl_rx_dchan(struct msgb *msg) msg->lchan = lchan_lookup(msg->trx, rslh->chan_nr); ts_name = gsm_ts_name(msg->lchan->ts); - DEBUGP(DRSL, "channel=%s chan_nr=0x%02x ", ts_name, rslh->chan_nr); + if (rslh->c.msg_type != RSL_MT_MEAS_RES) + DEBUGP(DRSL, "channel=%s chan_nr=0x%02x ", ts_name, rslh->chan_nr); switch (rslh->c.msg_type) { case RSL_MT_CHAN_ACTIV_ACK: diff --git a/openbsc/src/debug.c b/openbsc/src/debug.c index aeb993097..6483710af 100644 --- a/openbsc/src/debug.c +++ b/openbsc/src/debug.c @@ -28,7 +28,7 @@ #include -unsigned int debug_mask = 0xffffffff & ~(DMI|DMIB); +unsigned int debug_mask = 0xffffffff & ~(DMI|DMIB|DMEAS); struct debug_info { const char *name; @@ -56,6 +56,7 @@ static const struct debug_info debug_info[] = { DEBUG_CATEGORY(DMI, "DMI", "", "") DEBUG_CATEGORY(DMIB, "DMIB", "", "") DEBUG_CATEGORY(DMUX, "DMUX", "", "") + DEBUG_CATEGORY(DMEAS, "DMEAS", "", "") }; static int use_color = 1; diff --git a/openbsc/src/gsm_04_08.c b/openbsc/src/gsm_04_08.c index 6d8530bcb..56d3a1ccb 100644 --- a/openbsc/src/gsm_04_08.c +++ b/openbsc/src/gsm_04_08.c @@ -1697,20 +1697,20 @@ static int gsm48_rx_rr_meas_rep(struct msgb *msg) unsigned int payload_len = msgb_l3len(msg) - sizeof(*gh); static struct gsm_meas_rep meas_rep; - DEBUGP(DRR, "MEASUREMENT REPORT "); + DEBUGP(DMEAS, "MEASUREMENT REPORT "); parse_meas_rep(&meas_rep, gh->data, payload_len); if (meas_rep.flags & MEAS_REP_F_DTX) - DEBUGPC(DRR, "DTX "); + DEBUGPC(DMEAS, "DTX "); if (meas_rep.flags & MEAS_REP_F_BA1) - DEBUGPC(DRR, "BA1 "); + DEBUGPC(DMEAS, "BA1 "); if (!(meas_rep.flags & MEAS_REP_F_VALID)) - DEBUGPC(DRR, "NOT VALID "); + DEBUGPC(DMEAS, "NOT VALID "); else - DEBUGPC(DRR, "FULL(lev=%u, qual=%u) SUB(lev=%u, qual=%u) ", + DEBUGPC(DMEAS, "FULL(lev=%u, qual=%u) SUB(lev=%u, qual=%u) ", meas_rep.rxlev_full, meas_rep.rxqual_full, meas_rep.rxlev_sub, meas_rep.rxqual_sub); - DEBUGPC(DRR, "NUM_NEIGH=%u\n", meas_rep.num_cell); + DEBUGPC(DMEAS, "NUM_NEIGH=%u\n", meas_rep.num_cell); /* FIXME: put the results somwhere */ -- cgit v1.2.3 From a0368540ab965a0d05bab113a72f8a4a9ec8aa20 Mon Sep 17 00:00:00 2001 From: Harald Welte Date: Sat, 27 Jun 2009 02:58:43 +0200 Subject: cosmetic cleanup of LOCATION UPDATE REQ print-out --- openbsc/src/gsm_04_08.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) (limited to 'openbsc') diff --git a/openbsc/src/gsm_04_08.c b/openbsc/src/gsm_04_08.c index 56d3a1ccb..dc70c866a 100644 --- a/openbsc/src/gsm_04_08.c +++ b/openbsc/src/gsm_04_08.c @@ -1206,7 +1206,7 @@ static int mm_rx_loc_upd_req(struct msgb *msg) mi_to_string(mi_string, sizeof(mi_string), lu->mi, lu->mi_len); - DEBUGP(DMM, "LUPDREQ: mi_type=0x%02x MI(%s) type=%s\n", mi_type, mi_string, + DEBUGPC(DMM, "mi_type=0x%02x MI(%s) type=%s ", mi_type, mi_string, lupd_name(lu->type)); /* @@ -1214,7 +1214,7 @@ static int mm_rx_loc_upd_req(struct msgb *msg) * location updating request. */ if (lchan->loc_operation) { - DEBUGP(DMM, "LUPDREQ: ignoring request due an existing one: %p.\n", + DEBUGPC(DMM, "ignoring request due an existing one: %p.\n", lchan->loc_operation); gsm0408_loc_upd_rej(lchan, GSM48_REJECT_PROTOCOL_ERROR); return 0; @@ -1224,7 +1224,7 @@ static int mm_rx_loc_upd_req(struct msgb *msg) switch (mi_type) { case GSM_MI_TYPE_IMSI: - DEBUGP(DMM, "\n"); + DEBUGPC(DMM, "\n"); /* we always want the IMEI, too */ rc = mm_tx_identity_req(lchan, GSM_MI_TYPE_IMEI); lchan->loc_operation->waiting_for_imei = 1; @@ -1233,7 +1233,7 @@ static int mm_rx_loc_upd_req(struct msgb *msg) subscr = db_create_subscriber(mi_string); break; case GSM_MI_TYPE_TMSI: - DEBUGP(DMM, "\n"); + DEBUGPC(DMM, "\n"); /* we always want the IMEI, too */ rc = mm_tx_identity_req(lchan, GSM_MI_TYPE_IMEI); lchan->loc_operation->waiting_for_imei = 1; @@ -1249,15 +1249,15 @@ static int mm_rx_loc_upd_req(struct msgb *msg) case GSM_MI_TYPE_IMEI: case GSM_MI_TYPE_IMEISV: /* no sim card... FIXME: what to do ? */ - DEBUGP(DMM, "unimplemented mobile identity type\n"); + DEBUGPC(DMM, "unimplemented mobile identity type\n"); break; default: - DEBUGP(DMM, "unknown mobile identity type\n"); + DEBUGPC(DMM, "unknown mobile identity type\n"); break; } if (!subscr) { - DEBUGP(DRR, "<- Can't find any subscriber for this ID\n"); + DEBUGPC(DRR, "<- Can't find any subscriber for this ID\n"); /* FIXME: request id? close channel? */ return -EINVAL; } @@ -1535,7 +1535,7 @@ static int gsm0408_rcv_mm(struct msgb *msg) switch (gh->msg_type & 0xbf) { case GSM48_MT_MM_LOC_UPD_REQUEST: - DEBUGP(DMM, "LOCATION UPDATING REQUEST\n"); + DEBUGP(DMM, "LOCATION UPDATING REQUEST: "); rc = mm_rx_loc_upd_req(msg); break; case GSM48_MT_MM_ID_RESP: -- cgit v1.2.3 From eab33356d0685fa93cc29a30c0bcd5ffbf1a543d Mon Sep 17 00:00:00 2001 From: Harald Welte Date: Sat, 27 Jun 2009 03:09:08 +0200 Subject: fix various RSL msgb memory leaks in error paths --- openbsc/src/abis_rsl.c | 14 ++++++++++---- openbsc/src/e1_input.c | 1 + 2 files changed, 11 insertions(+), 4 deletions(-) (limited to 'openbsc') diff --git a/openbsc/src/abis_rsl.c b/openbsc/src/abis_rsl.c index 397d793c7..c2ef9e5cf 100644 --- a/openbsc/src/abis_rsl.c +++ b/openbsc/src/abis_rsl.c @@ -360,13 +360,15 @@ int rsl_sacch_filling(struct gsm_bts_trx *trx, u_int8_t type, int rsl_chan_bs_power_ctrl(struct gsm_lchan *lchan, unsigned int fpc, int db) { struct abis_rsl_dchan_hdr *dh; - struct msgb *msg = rsl_msgb_alloc(); + struct msgb *msg; u_int8_t chan_nr = lchan2chan_nr(lchan); db = abs(db); if (db > 30) return -EINVAL; + msg = rsl_msgb_alloc(); + lchan->bs_power = db/2; if (fpc) lchan->bs_power |= 0x10; @@ -457,7 +459,7 @@ static int ms_pwr_dbm(enum gsm_band band, u_int8_t lvl) int rsl_chan_ms_power_ctrl(struct gsm_lchan *lchan, unsigned int fpc, int dbm) { struct abis_rsl_dchan_hdr *dh; - struct msgb *msg = rsl_msgb_alloc(); + struct msgb *msg; u_int8_t chan_nr = lchan2chan_nr(lchan); int ctl_lvl; @@ -465,6 +467,8 @@ int rsl_chan_ms_power_ctrl(struct gsm_lchan *lchan, unsigned int fpc, int dbm) if (ctl_lvl < 0) return ctl_lvl; + msg = rsl_msgb_alloc(); + lchan->ms_power = ctl_lvl; if (fpc) @@ -521,7 +525,7 @@ int rsl_chan_activate_lchan(struct gsm_lchan *lchan, u_int8_t act_type, u_int8_t ta, u_int8_t mode) { struct abis_rsl_dchan_hdr *dh; - struct msgb *msg = rsl_msgb_alloc(); + struct msgb *msg; u_int8_t chan_nr = lchan2chan_nr(lchan); u_int16_t arfcn = lchan->ts->trx->arfcn; @@ -564,6 +568,7 @@ int rsl_chan_activate_lchan(struct gsm_lchan *lchan, u_int8_t act_type, ci.chan_desc.oct3 = (lchan->ts->trx->bts->tsc << 5) | ((arfcn & 0x3ff) >> 8); ci.chan_desc.oct4 = arfcn & 0xff; + msg = rsl_msgb_alloc(); dh = (struct abis_rsl_dchan_hdr *) msgb_put(msg, sizeof(*dh)); init_dchan_hdr(dh, RSL_MT_CHAN_ACTIV); dh->chan_nr = chan_nr; @@ -591,7 +596,7 @@ int rsl_chan_activate_lchan(struct gsm_lchan *lchan, u_int8_t act_type, int rsl_chan_mode_modify_req(struct gsm_lchan *lchan) { struct abis_rsl_dchan_hdr *dh; - struct msgb *msg = rsl_msgb_alloc(); + struct msgb *msg; u_int8_t chan_nr = lchan2chan_nr(lchan); struct rsl_ie_chan_mode cm; @@ -622,6 +627,7 @@ int rsl_chan_mode_modify_req(struct gsm_lchan *lchan) return -1; } + msg = rsl_msgb_alloc(); dh = (struct abis_rsl_dchan_hdr *) msgb_put(msg, sizeof(*dh)); init_dchan_hdr(dh, RSL_MT_MODE_MODIFY_REQ); dh->chan_nr = chan_nr; diff --git a/openbsc/src/e1_input.c b/openbsc/src/e1_input.c index 56bce019c..2d0c1340f 100644 --- a/openbsc/src/e1_input.c +++ b/openbsc/src/e1_input.c @@ -236,6 +236,7 @@ int abis_rsl_sendmsg(struct msgb *msg) if (!msg->trx || !msg->trx->rsl_link) { fprintf(stderr, "rsl_sendmsg: msg->trx == NULL\n"); + talloc_free(msg); return -EINVAL; } -- cgit v1.2.3