00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025 #include "asterisk.h"
00026
00027 ASTERISK_FILE_VERSION(__FILE__, "$Revision: 424786 $")
00028
00029 #include "asterisk/_private.h"
00030 #include "asterisk/astobj2.h"
00031 #include "asterisk/utils.h"
00032 #include "asterisk/cli.h"
00033 #include "asterisk/paths.h"
00034
00035 static FILE *ref_log;
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047 struct __priv_data {
00048 ast_mutex_t lock;
00049 int ref_counter;
00050 ao2_destructor_fn destructor_fn;
00051
00052 size_t data_size;
00053
00054
00055 uint32_t magic;
00056 };
00057
00058 #define AO2_MAGIC 0xa570b123
00059
00060
00061
00062
00063
00064 struct astobj2 {
00065 struct __priv_data priv_data;
00066 void *user_data[0];
00067 };
00068
00069 #ifdef AST_DEVMODE
00070
00071 #endif
00072
00073 #ifdef AO2_DEBUG
00074 struct ao2_stats {
00075 volatile int total_objects;
00076 volatile int total_mem;
00077 volatile int total_containers;
00078 volatile int total_refs;
00079 volatile int total_locked;
00080 };
00081
00082 static struct ao2_stats ao2;
00083 #endif
00084
00085 #ifndef HAVE_BKTR
00086 void ao2_bt(void) {}
00087 #else
00088 #include <execinfo.h>
00089
00090 void ao2_bt(void)
00091 {
00092 int c, i;
00093 #define N1 20
00094 void *addresses[N1];
00095 char **strings;
00096
00097 c = backtrace(addresses, N1);
00098 strings = ast_bt_get_symbols(addresses,c);
00099 ast_verbose("backtrace returned: %d\n", c);
00100 for(i = 0; i < c; i++) {
00101 ast_verbose("%d: %p %s\n", i, addresses[i], strings[i]);
00102 }
00103 ast_std_free(strings);
00104 }
00105 #endif
00106
00107
00108
00109
00110
00111
00112 static inline struct astobj2 *INTERNAL_OBJ(void *user_data)
00113 {
00114 struct astobj2 *p;
00115
00116 if (!user_data) {
00117 ast_log(LOG_ERROR, "user_data is NULL\n");
00118 return NULL;
00119 }
00120
00121 p = (struct astobj2 *) ((char *) user_data - sizeof(*p));
00122 if (AO2_MAGIC != p->priv_data.magic) {
00123 if (p->priv_data.magic) {
00124 ast_log(LOG_ERROR, "bad magic number 0x%x for object %p\n",
00125 p->priv_data.magic, user_data);
00126 } else {
00127 ast_log(LOG_ERROR,
00128 "bad magic number for object %p. Object is likely destroyed.\n",
00129 user_data);
00130 }
00131 ast_assert(0);
00132 return NULL;
00133 }
00134
00135 return p;
00136 }
00137
00138 enum ao2_callback_type {
00139 DEFAULT,
00140 WITH_DATA,
00141 };
00142
00143
00144
00145
00146
00147
00148 #define EXTERNAL_OBJ(_p) ((_p) == NULL ? NULL : (_p)->user_data)
00149
00150
00151
00152 static int internal_ao2_ref(void *user_data, const int delta);
00153 static struct ao2_container *internal_ao2_container_alloc(struct ao2_container *c, const uint n_buckets, ao2_hash_fn *hash_fn,
00154 ao2_callback_fn *cmp_fn);
00155 static struct bucket_entry *internal_ao2_link(struct ao2_container *c, void *user_data, const char *file, int line, const char *func);
00156 static void *internal_ao2_callback(struct ao2_container *c,
00157 const enum search_flags flags, void *cb_fn, void *arg, void *data, enum ao2_callback_type type,
00158 char *tag, char *file, int line, const char *funcname);
00159 static void *internal_ao2_iterator_next(struct ao2_iterator *a, struct bucket_entry **q);
00160
00161 int __ao2_lock(void *user_data, const char *file, const char *func, int line, const char *var)
00162 {
00163 struct astobj2 *p = INTERNAL_OBJ(user_data);
00164
00165 if (p == NULL)
00166 return -1;
00167
00168 #ifdef AO2_DEBUG
00169 ast_atomic_fetchadd_int(&ao2.total_locked, 1);
00170 #endif
00171
00172 return __ast_pthread_mutex_lock(file, line, func, var, &p->priv_data.lock);
00173 }
00174
00175 int __ao2_unlock(void *user_data, const char *file, const char *func, int line, const char *var)
00176 {
00177 struct astobj2 *p = INTERNAL_OBJ(user_data);
00178
00179 if (p == NULL)
00180 return -1;
00181
00182 #ifdef AO2_DEBUG
00183 ast_atomic_fetchadd_int(&ao2.total_locked, -1);
00184 #endif
00185
00186 return __ast_pthread_mutex_unlock(file, line, func, var, &p->priv_data.lock);
00187 }
00188
00189 int __ao2_trylock(void *user_data, const char *file, const char *func, int line, const char *var)
00190 {
00191 struct astobj2 *p = INTERNAL_OBJ(user_data);
00192 int ret;
00193
00194 if (p == NULL)
00195 return -1;
00196 ret = __ast_pthread_mutex_trylock(file, line, func, var, &p->priv_data.lock);
00197
00198 #ifdef AO2_DEBUG
00199 if (!ret)
00200 ast_atomic_fetchadd_int(&ao2.total_locked, 1);
00201 #endif
00202 return ret;
00203 }
00204
00205 void *ao2_object_get_lockaddr(void *obj)
00206 {
00207 struct astobj2 *p = INTERNAL_OBJ(obj);
00208
00209 if (p == NULL)
00210 return NULL;
00211
00212 return &p->priv_data.lock;
00213 }
00214
00215
00216
00217
00218
00219 int __ao2_ref_debug(void *user_data, const int delta, const char *tag, const char *file, int line, const char *funcname)
00220 {
00221 struct astobj2 *obj = INTERNAL_OBJ(user_data);
00222 int old_refcount = -1;
00223
00224 if (obj) {
00225 old_refcount = internal_ao2_ref(user_data, delta);
00226 }
00227
00228 if (ref_log && user_data) {
00229 if (!obj) {
00230
00231 fprintf(ref_log, "%p,%d,%d,%s,%d,%s,**invalid**,%s\n",
00232 user_data, delta, ast_get_tid(), file, line, funcname, tag);
00233 fflush(ref_log);
00234 } else if (old_refcount + delta == 0) {
00235 fprintf(ref_log, "%p,%d,%d,%s,%d,%s,**destructor**,%s\n",
00236 user_data, delta, ast_get_tid(), file, line, funcname, tag);
00237 fflush(ref_log);
00238 } else if (delta != 0) {
00239 fprintf(ref_log, "%p,%s%d,%d,%s,%d,%s,%d,%s\n", user_data, (delta < 0 ? "" : "+"),
00240 delta, ast_get_tid(), file, line, funcname, old_refcount, tag);
00241 fflush(ref_log);
00242 }
00243 }
00244
00245 return old_refcount;
00246 }
00247
00248 int __ao2_ref(void *user_data, const int delta)
00249 {
00250 return internal_ao2_ref(user_data, delta);
00251 }
00252
00253 static int internal_ao2_ref(void *user_data, const int delta)
00254 {
00255 struct astobj2 *obj = INTERNAL_OBJ(user_data);
00256 int current_value;
00257 int ret;
00258
00259 if (obj == NULL)
00260 return -1;
00261
00262
00263 if (delta == 0)
00264 return (obj->priv_data.ref_counter);
00265
00266
00267 ret = ast_atomic_fetchadd_int(&obj->priv_data.ref_counter, delta);
00268 current_value = ret + delta;
00269
00270 #ifdef AO2_DEBUG
00271 ast_atomic_fetchadd_int(&ao2.total_refs, delta);
00272 #endif
00273
00274
00275 if (current_value < 0)
00276 ast_log(LOG_ERROR, "refcount %d on object %p\n", current_value, user_data);
00277
00278 if (current_value <= 0) {
00279 if (obj->priv_data.destructor_fn != NULL) {
00280 obj->priv_data.destructor_fn(user_data);
00281 }
00282
00283 ast_mutex_destroy(&obj->priv_data.lock);
00284 #ifdef AO2_DEBUG
00285 ast_atomic_fetchadd_int(&ao2.total_mem, - obj->priv_data.data_size);
00286 ast_atomic_fetchadd_int(&ao2.total_objects, -1);
00287 #endif
00288
00289
00290
00291 memset(obj, '\0', sizeof(struct astobj2 *) + sizeof(void *) );
00292 ast_free(obj);
00293 }
00294
00295 return ret;
00296 }
00297
00298
00299
00300
00301
00302 static void *internal_ao2_alloc(size_t data_size, ao2_destructor_fn destructor_fn, const char *file, int line, const char *funcname)
00303 {
00304
00305 struct astobj2 *obj;
00306
00307 if (data_size < sizeof(void *))
00308 data_size = sizeof(void *);
00309
00310 #if defined(__AST_DEBUG_MALLOC)
00311 obj = __ast_calloc(1, sizeof(*obj) + data_size, file, line, funcname);
00312 #else
00313 obj = ast_calloc(1, sizeof(*obj) + data_size);
00314 #endif
00315
00316 if (obj == NULL)
00317 return NULL;
00318
00319 ast_mutex_init(&obj->priv_data.lock);
00320 obj->priv_data.magic = AO2_MAGIC;
00321 obj->priv_data.data_size = data_size;
00322 obj->priv_data.ref_counter = 1;
00323 obj->priv_data.destructor_fn = destructor_fn;
00324
00325 #ifdef AO2_DEBUG
00326 ast_atomic_fetchadd_int(&ao2.total_objects, 1);
00327 ast_atomic_fetchadd_int(&ao2.total_mem, data_size);
00328 ast_atomic_fetchadd_int(&ao2.total_refs, 1);
00329 #endif
00330
00331
00332 return EXTERNAL_OBJ(obj);
00333 }
00334
00335 void *__ao2_alloc_debug(size_t data_size, ao2_destructor_fn destructor_fn, char *tag,
00336 const char *file, int line, const char *funcname, int ref_debug)
00337 {
00338
00339 void *obj;
00340
00341 if ((obj = internal_ao2_alloc(data_size, destructor_fn, file, line, funcname)) == NULL) {
00342 return NULL;
00343 }
00344
00345 if (ref_log) {
00346 fprintf(ref_log, "%p,+1,%d,%s,%d,%s,**constructor**,%s\n", obj, ast_get_tid(), file, line, funcname, tag);
00347 fflush(ref_log);
00348 }
00349
00350
00351 return obj;
00352 }
00353
00354 void *__ao2_alloc(size_t data_size, ao2_destructor_fn destructor_fn)
00355 {
00356 return internal_ao2_alloc(data_size, destructor_fn, __FILE__, __LINE__, __FUNCTION__);
00357 }
00358
00359
00360
00361 static void container_destruct(void *c);
00362
00363
00364 static void container_destruct_debug(void *c);
00365
00366
00367 AST_LIST_HEAD_NOLOCK(bucket, bucket_entry);
00368
00369
00370
00371
00372
00373
00374
00375
00376
00377
00378
00379
00380
00381
00382
00383
00384
00385
00386
00387
00388
00389
00390
00391 struct ao2_container {
00392 ao2_hash_fn *hash_fn;
00393 ao2_callback_fn *cmp_fn;
00394 int n_buckets;
00395
00396 int elements;
00397
00398 int version;
00399
00400 struct bucket buckets[0];
00401 };
00402
00403
00404
00405
00406
00407
00408
00409
00410
00411
00412 static int hash_zero(const void *user_obj, const int flags)
00413 {
00414 return 0;
00415 }
00416
00417
00418
00419
00420 static struct ao2_container *internal_ao2_container_alloc(struct ao2_container *c, const unsigned int n_buckets, ao2_hash_fn *hash_fn,
00421 ao2_callback_fn *cmp_fn)
00422 {
00423
00424
00425
00426 if (!c)
00427 return NULL;
00428
00429 c->version = 1;
00430 c->n_buckets = hash_fn ? n_buckets : 1;
00431 c->hash_fn = hash_fn ? hash_fn : hash_zero;
00432 c->cmp_fn = cmp_fn;
00433
00434 #ifdef AO2_DEBUG
00435 ast_atomic_fetchadd_int(&ao2.total_containers, 1);
00436 #endif
00437
00438 return c;
00439 }
00440
00441 struct ao2_container *__ao2_container_alloc_debug(const unsigned int n_buckets, ao2_hash_fn *hash_fn,
00442 ao2_callback_fn *cmp_fn, char *tag, char *file, int line,
00443 const char *funcname, int ref_debug)
00444 {
00445
00446
00447 const unsigned int num_buckets = hash_fn ? n_buckets : 1;
00448 size_t container_size = sizeof(struct ao2_container) + num_buckets * sizeof(struct bucket);
00449 struct ao2_container *c = __ao2_alloc_debug(container_size, ref_debug ? container_destruct_debug : container_destruct, tag, file, line, funcname, ref_debug);
00450
00451 return internal_ao2_container_alloc(c, num_buckets, hash_fn, cmp_fn);
00452 }
00453
00454 struct ao2_container *__ao2_container_alloc(const unsigned int n_buckets, ao2_hash_fn *hash_fn,
00455 ao2_callback_fn *cmp_fn)
00456 {
00457
00458
00459
00460 const unsigned int num_buckets = hash_fn ? n_buckets : 1;
00461 size_t container_size = sizeof(struct ao2_container) + num_buckets * sizeof(struct bucket);
00462 struct ao2_container *c = __ao2_alloc(container_size, container_destruct);
00463
00464 return internal_ao2_container_alloc(c, num_buckets, hash_fn, cmp_fn);
00465 }
00466
00467
00468
00469
00470 int ao2_container_count(struct ao2_container *c)
00471 {
00472 return c->elements;
00473 }
00474
00475
00476
00477
00478
00479
00480 struct bucket_entry {
00481 AST_LIST_ENTRY(bucket_entry) entry;
00482 int version;
00483 struct astobj2 *astobj;
00484 };
00485
00486
00487
00488
00489
00490 static struct bucket_entry *internal_ao2_link(struct ao2_container *c, void *user_data, const char *file, int line, const char *func)
00491 {
00492 int i;
00493
00494 struct bucket_entry *p;
00495 struct astobj2 *obj = INTERNAL_OBJ(user_data);
00496
00497 if (obj == NULL)
00498 return NULL;
00499
00500 if (INTERNAL_OBJ(c) == NULL)
00501 return NULL;
00502
00503 p = ast_calloc(1, sizeof(*p));
00504 if (!p)
00505 return NULL;
00506
00507 i = abs(c->hash_fn(user_data, OBJ_POINTER));
00508
00509 ao2_lock(c);
00510 i %= c->n_buckets;
00511 p->astobj = obj;
00512 p->version = ast_atomic_fetchadd_int(&c->version, 1);
00513 AST_LIST_INSERT_TAIL(&c->buckets[i], p, entry);
00514 ast_atomic_fetchadd_int(&c->elements, 1);
00515
00516
00517 return p;
00518 }
00519
00520 void *__ao2_link_debug(struct ao2_container *c, void *user_data, char *tag, char *file, int line, const char *funcname)
00521 {
00522 struct bucket_entry *p = internal_ao2_link(c, user_data, file, line, funcname);
00523
00524 if (p) {
00525 __ao2_ref_debug(user_data, +1, tag, file, line, funcname);
00526 ao2_unlock(c);
00527 }
00528 return p;
00529 }
00530
00531 void *__ao2_link(struct ao2_container *c, void *user_data)
00532 {
00533 struct bucket_entry *p = internal_ao2_link(c, user_data, __FILE__, __LINE__, __PRETTY_FUNCTION__);
00534
00535 if (p) {
00536 __ao2_ref(user_data, +1);
00537 ao2_unlock(c);
00538 }
00539 return p;
00540 }
00541
00542
00543
00544
00545 int ao2_match_by_addr(void *user_data, void *arg, int flags)
00546 {
00547 return (user_data == arg) ? (CMP_MATCH | CMP_STOP) : 0;
00548 }
00549
00550
00551
00552
00553
00554 void *__ao2_unlink_debug(struct ao2_container *c, void *user_data, char *tag,
00555 char *file, int line, const char *funcname)
00556 {
00557 if (INTERNAL_OBJ(user_data) == NULL)
00558 return NULL;
00559
00560 __ao2_callback_debug(c, OBJ_UNLINK | OBJ_POINTER | OBJ_NODATA, ao2_match_by_addr, user_data, tag, file, line, funcname);
00561
00562 return NULL;
00563 }
00564
00565 void *__ao2_unlink(struct ao2_container *c, void *user_data)
00566 {
00567 if (INTERNAL_OBJ(user_data) == NULL)
00568 return NULL;
00569
00570 __ao2_callback(c, OBJ_UNLINK | OBJ_POINTER | OBJ_NODATA, ao2_match_by_addr, user_data);
00571
00572 return NULL;
00573 }
00574
00575
00576
00577
00578 static int cb_true(void *user_data, void *arg, int flags)
00579 {
00580 return CMP_MATCH;
00581 }
00582
00583
00584
00585
00586 static int cb_true_data(void *user_data, void *arg, void *data, int flags)
00587 {
00588 return CMP_MATCH;
00589 }
00590
00591
00592
00593
00594
00595
00596
00597
00598
00599 static void *internal_ao2_callback(struct ao2_container *c,
00600 const enum search_flags flags, void *cb_fn, void *arg, void *data, enum ao2_callback_type type,
00601 char *tag, char *file, int line, const char *funcname)
00602 {
00603 int i, start, last;
00604 void *ret = NULL;
00605 ao2_callback_fn *cb_default = NULL;
00606 ao2_callback_data_fn *cb_withdata = NULL;
00607 struct ao2_container *multi_container = NULL;
00608 struct ao2_iterator *multi_iterator = NULL;
00609
00610 if (INTERNAL_OBJ(c) == NULL)
00611 return NULL;
00612
00613
00614
00615
00616
00617
00618 if ((flags & (OBJ_MULTIPLE | OBJ_NODATA)) == OBJ_MULTIPLE) {
00619
00620
00621
00622
00623
00624
00625
00626 if (!(multi_container = ao2_container_alloc(1, NULL, NULL))) {
00627 return NULL;
00628 }
00629 if (!(multi_iterator = ast_calloc(1, sizeof(*multi_iterator)))) {
00630 ao2_ref(multi_container, -1);
00631 return NULL;
00632 }
00633 }
00634
00635
00636 if (cb_fn == NULL) {
00637 if (type == WITH_DATA) {
00638 cb_withdata = cb_true_data;
00639 } else {
00640 cb_default = cb_true;
00641 }
00642 } else {
00643
00644
00645 if (type == WITH_DATA) {
00646 cb_withdata = cb_fn;
00647 } else {
00648 cb_default = cb_fn;
00649 }
00650 }
00651
00652
00653
00654
00655
00656
00657
00658 if ((flags & OBJ_POINTER))
00659 start = i = c->hash_fn(arg, flags & OBJ_POINTER) % c->n_buckets;
00660 else
00661 start = i = -1;
00662
00663
00664 if (i < 0) {
00665 start = i = 0;
00666 last = c->n_buckets;
00667 } else if ((flags & OBJ_CONTINUE)) {
00668 last = c->n_buckets;
00669 } else {
00670 last = i + 1;
00671 }
00672
00673 ao2_lock(c);
00674
00675 for (; i < last ; i++) {
00676
00677 struct bucket_entry *cur;
00678
00679 AST_LIST_TRAVERSE_SAFE_BEGIN(&c->buckets[i], cur, entry) {
00680 int match = (CMP_MATCH | CMP_STOP);
00681
00682 if (type == WITH_DATA) {
00683 match &= cb_withdata(EXTERNAL_OBJ(cur->astobj), arg, data, flags);
00684 } else {
00685 match &= cb_default(EXTERNAL_OBJ(cur->astobj), arg, flags);
00686 }
00687
00688
00689 if (match == 0) {
00690 continue;
00691 } else if (match == CMP_STOP) {
00692 i = last;
00693 break;
00694 }
00695
00696
00697 if (!(flags & OBJ_NODATA)) {
00698
00699 ret = EXTERNAL_OBJ(cur->astobj);
00700 if (!(flags & (OBJ_UNLINK | OBJ_MULTIPLE))) {
00701 if (tag)
00702 __ao2_ref_debug(ret, 1, tag, file, line, funcname);
00703 else
00704 __ao2_ref(ret, 1);
00705 }
00706 }
00707
00708
00709
00710
00711 if (ret && (multi_container != NULL)) {
00712 if (tag) {
00713 __ao2_link_debug(multi_container, ret, tag, file, line, funcname);
00714 } else {
00715 __ao2_link(multi_container, ret);
00716 }
00717 ret = NULL;
00718 }
00719
00720 if (flags & OBJ_UNLINK) {
00721
00722 ast_atomic_fetchadd_int(&c->version, 1);
00723 AST_LIST_REMOVE_CURRENT(entry);
00724
00725 ast_atomic_fetchadd_int(&c->elements, -1);
00726
00727
00728
00729
00730
00731
00732
00733 if (flags & (OBJ_NODATA | OBJ_MULTIPLE)) {
00734 if (tag)
00735 __ao2_ref_debug(EXTERNAL_OBJ(cur->astobj), -1, tag, file, line, funcname);
00736 else
00737 __ao2_ref(EXTERNAL_OBJ(cur->astobj), -1);
00738 }
00739 ast_free(cur);
00740 }
00741
00742 if ((match & CMP_STOP) || !(flags & OBJ_MULTIPLE)) {
00743
00744
00745 i = last;
00746 break;
00747 }
00748 }
00749 AST_LIST_TRAVERSE_SAFE_END;
00750
00751 if (ret) {
00752 break;
00753 }
00754
00755 if (i == c->n_buckets - 1 && (flags & OBJ_POINTER) && (flags & OBJ_CONTINUE)) {
00756
00757 i = -1;
00758 last = start;
00759 }
00760 }
00761 ao2_unlock(c);
00762
00763
00764 if (multi_container != NULL) {
00765 *multi_iterator = ao2_iterator_init(multi_container,
00766 AO2_ITERATOR_DONTLOCK | AO2_ITERATOR_UNLINK | AO2_ITERATOR_MALLOCD);
00767 ao2_ref(multi_container, -1);
00768 return multi_iterator;
00769 } else {
00770 return ret;
00771 }
00772 }
00773
00774 void *__ao2_callback_debug(struct ao2_container *c,
00775 const enum search_flags flags,
00776 ao2_callback_fn *cb_fn, void *arg,
00777 char *tag, char *file, int line, const char *funcname)
00778 {
00779 return internal_ao2_callback(c,flags, cb_fn, arg, NULL, DEFAULT, tag, file, line, funcname);
00780 }
00781
00782 void *__ao2_callback(struct ao2_container *c, const enum search_flags flags,
00783 ao2_callback_fn *cb_fn, void *arg)
00784 {
00785 return internal_ao2_callback(c,flags, cb_fn, arg, NULL, DEFAULT, NULL, NULL, 0, NULL);
00786 }
00787
00788 void *__ao2_callback_data_debug(struct ao2_container *c,
00789 const enum search_flags flags,
00790 ao2_callback_data_fn *cb_fn, void *arg, void *data,
00791 char *tag, char *file, int line, const char *funcname)
00792 {
00793 return internal_ao2_callback(c, flags, cb_fn, arg, data, WITH_DATA, tag, file, line, funcname);
00794 }
00795
00796 void *__ao2_callback_data(struct ao2_container *c, const enum search_flags flags,
00797 ao2_callback_data_fn *cb_fn, void *arg, void *data)
00798 {
00799 return internal_ao2_callback(c, flags, cb_fn, arg, data, WITH_DATA, NULL, NULL, 0, NULL);
00800 }
00801
00802
00803
00804
00805 void *__ao2_find_debug(struct ao2_container *c, void *arg, enum search_flags flags, char *tag, char *file, int line, const char *funcname)
00806 {
00807 return __ao2_callback_debug(c, flags, c->cmp_fn, arg, tag, file, line, funcname);
00808 }
00809
00810 void *__ao2_find(struct ao2_container *c, void *arg, enum search_flags flags)
00811 {
00812 return __ao2_callback(c, flags, c->cmp_fn, arg);
00813 }
00814
00815
00816
00817
00818 struct ao2_iterator ao2_iterator_init(struct ao2_container *c, int flags)
00819 {
00820 struct ao2_iterator a = {
00821 .c = c,
00822 .flags = flags
00823 };
00824
00825 ao2_ref(c, +1);
00826
00827 return a;
00828 }
00829
00830
00831
00832
00833 void ao2_iterator_destroy(struct ao2_iterator *i)
00834 {
00835 ao2_ref(i->c, -1);
00836 if (i->flags & AO2_ITERATOR_MALLOCD) {
00837 ast_free(i);
00838 } else {
00839 i->c = NULL;
00840 }
00841 }
00842
00843
00844
00845
00846 static void *internal_ao2_iterator_next(struct ao2_iterator *a, struct bucket_entry **q)
00847 {
00848 int lim;
00849 struct bucket_entry *p = NULL;
00850 void *ret = NULL;
00851
00852 *q = NULL;
00853
00854 if (INTERNAL_OBJ(a->c) == NULL)
00855 return NULL;
00856
00857 if (!(a->flags & AO2_ITERATOR_DONTLOCK))
00858 ao2_lock(a->c);
00859
00860
00861
00862
00863 if (a->c->version == a->c_version && (p = a->obj)) {
00864 if ((p = AST_LIST_NEXT(p, entry)))
00865 goto found;
00866
00867 a->bucket++;
00868 a->version = 0;
00869 a->obj = NULL;
00870 }
00871
00872 lim = a->c->n_buckets;
00873
00874
00875
00876
00877
00878
00879
00880 for (; a->bucket < lim; a->bucket++, a->version = 0) {
00881
00882 AST_LIST_TRAVERSE(&a->c->buckets[a->bucket], p, entry) {
00883 if (p->version > a->version)
00884 goto found;
00885 }
00886 }
00887
00888 found:
00889 if (p) {
00890 ret = EXTERNAL_OBJ(p->astobj);
00891 if (a->flags & AO2_ITERATOR_UNLINK) {
00892
00893 ast_atomic_fetchadd_int(&a->c->version, 1);
00894 AST_LIST_REMOVE(&a->c->buckets[a->bucket], p, entry);
00895
00896 ast_atomic_fetchadd_int(&a->c->elements, -1);
00897 a->version = 0;
00898 a->obj = NULL;
00899 a->c_version = a->c->version;
00900 ast_free(p);
00901 } else {
00902 a->version = p->version;
00903 a->obj = p;
00904 a->c_version = a->c->version;
00905
00906 *q = p;
00907 }
00908 }
00909
00910 return ret;
00911 }
00912
00913 void *__ao2_iterator_next_debug(struct ao2_iterator *a, char *tag, char *file, int line, const char *funcname)
00914 {
00915 struct bucket_entry *p;
00916 void *ret = NULL;
00917
00918 ret = internal_ao2_iterator_next(a, &p);
00919
00920 if (p) {
00921
00922 __ao2_ref_debug(ret, 1, tag, file, line, funcname);
00923 }
00924
00925 if (!(a->flags & AO2_ITERATOR_DONTLOCK))
00926 ao2_unlock(a->c);
00927
00928 return ret;
00929 }
00930
00931 void *__ao2_iterator_next(struct ao2_iterator *a)
00932 {
00933 struct bucket_entry *p = NULL;
00934 void *ret = NULL;
00935
00936 ret = internal_ao2_iterator_next(a, &p);
00937
00938 if (p) {
00939
00940 __ao2_ref(ret, 1);
00941 }
00942
00943 if (!(a->flags & AO2_ITERATOR_DONTLOCK))
00944 ao2_unlock(a->c);
00945
00946 return ret;
00947 }
00948
00949
00950
00951
00952 static int cd_cb(void *obj, void *arg, int flag)
00953 {
00954 __ao2_ref(obj, -1);
00955 return 0;
00956 }
00957
00958 static int cd_cb_debug(void *obj, void *arg, int flag)
00959 {
00960 __ao2_ref_debug(obj, -1, "deref object via container destroy", __FILE__, __LINE__, __PRETTY_FUNCTION__);
00961 return 0;
00962 }
00963
00964 static void container_destruct(void *_c)
00965 {
00966 struct ao2_container *c = _c;
00967 int i;
00968
00969 __ao2_callback(c, OBJ_UNLINK, cd_cb, NULL);
00970
00971 for (i = 0; i < c->n_buckets; i++) {
00972 struct bucket_entry *current;
00973
00974 while ((current = AST_LIST_REMOVE_HEAD(&c->buckets[i], entry))) {
00975 ast_free(current);
00976 }
00977 }
00978
00979 #ifdef AO2_DEBUG
00980 ast_atomic_fetchadd_int(&ao2.total_containers, -1);
00981 #endif
00982 }
00983
00984 static void container_destruct_debug(void *_c)
00985 {
00986 struct ao2_container *c = _c;
00987 int i;
00988
00989 __ao2_callback_debug(c, OBJ_UNLINK, cd_cb_debug, NULL, "container_destruct_debug called", __FILE__, __LINE__, __PRETTY_FUNCTION__);
00990
00991 for (i = 0; i < c->n_buckets; i++) {
00992 struct bucket_entry *current;
00993
00994 while ((current = AST_LIST_REMOVE_HEAD(&c->buckets[i], entry))) {
00995 ast_free(current);
00996 }
00997 }
00998
00999 #ifdef AO2_DEBUG
01000 ast_atomic_fetchadd_int(&ao2.total_containers, -1);
01001 #endif
01002 }
01003
01004 #ifdef AO2_DEBUG
01005 static int print_cb(void *obj, void *arg, int flag)
01006 {
01007 struct ast_cli_args *a = (struct ast_cli_args *) arg;
01008 char *s = (char *)obj;
01009
01010 ast_cli(a->fd, "string <%s>\n", s);
01011 return 0;
01012 }
01013
01014
01015
01016
01017 static char *handle_astobj2_stats(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
01018 {
01019 switch (cmd) {
01020 case CLI_INIT:
01021 e->command = "astobj2 show stats";
01022 e->usage = "Usage: astobj2 show stats\n"
01023 " Show astobj2 show stats\n";
01024 return NULL;
01025 case CLI_GENERATE:
01026 return NULL;
01027 }
01028 ast_cli(a->fd, "Objects : %d\n", ao2.total_objects);
01029 ast_cli(a->fd, "Containers : %d\n", ao2.total_containers);
01030 ast_cli(a->fd, "Memory : %d\n", ao2.total_mem);
01031 ast_cli(a->fd, "Locked : %d\n", ao2.total_locked);
01032 ast_cli(a->fd, "Refs : %d\n", ao2.total_refs);
01033 return CLI_SUCCESS;
01034 }
01035
01036
01037
01038
01039 static char *handle_astobj2_test(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
01040 {
01041 struct ao2_container *c1;
01042 int i, lim;
01043 char *obj;
01044 static int prof_id = -1;
01045 struct ast_cli_args fake_args = { a->fd, 0, NULL };
01046
01047 switch (cmd) {
01048 case CLI_INIT:
01049 e->command = "astobj2 test";
01050 e->usage = "Usage: astobj2 test <num>\n"
01051 " Runs astobj2 test. Creates 'num' objects,\n"
01052 " and test iterators, callbacks and may be other stuff\n";
01053 return NULL;
01054 case CLI_GENERATE:
01055 return NULL;
01056 }
01057
01058 if (a->argc != 3) {
01059 return CLI_SHOWUSAGE;
01060 }
01061
01062 if (prof_id == -1)
01063 prof_id = ast_add_profile("ao2_alloc", 0);
01064
01065 ast_cli(a->fd, "argc %d argv %s %s %s\n", a->argc, a->argv[0], a->argv[1], a->argv[2]);
01066 lim = atoi(a->argv[2]);
01067 ast_cli(a->fd, "called astobj_test\n");
01068
01069 handle_astobj2_stats(e, CLI_HANDLER, &fake_args);
01070
01071
01072
01073
01074 c1 = ao2_t_container_alloc(100, NULL , NULL ,"test");
01075 ast_cli(a->fd, "container allocated as %p\n", c1);
01076
01077
01078
01079
01080
01081
01082 for (i = 0; i < lim; i++) {
01083 ast_mark(prof_id, 1 );
01084 obj = ao2_t_alloc(80, NULL,"test");
01085 ast_mark(prof_id, 0 );
01086 ast_cli(a->fd, "object %d allocated as %p\n", i, obj);
01087 sprintf(obj, "-- this is obj %d --", i);
01088 ao2_link(c1, obj);
01089
01090
01091
01092
01093
01094 ao2_t_ref(obj, -1, "test");
01095 }
01096 ast_cli(a->fd, "testing callbacks\n");
01097 ao2_t_callback(c1, 0, print_cb, a, "test callback");
01098 ast_cli(a->fd, "testing iterators, remove every second object\n");
01099 {
01100 struct ao2_iterator ai;
01101 int x = 0;
01102
01103 ai = ao2_iterator_init(c1, 0);
01104 while ( (obj = ao2_t_iterator_next(&ai,"test")) ) {
01105 ast_cli(a->fd, "iterator on <%s>\n", obj);
01106 if (x++ & 1)
01107 ao2_t_unlink(c1, obj,"test");
01108 ao2_t_ref(obj, -1,"test");
01109 }
01110 ao2_iterator_destroy(&ai);
01111 ast_cli(a->fd, "testing iterators again\n");
01112 ai = ao2_iterator_init(c1, 0);
01113 while ( (obj = ao2_t_iterator_next(&ai,"test")) ) {
01114 ast_cli(a->fd, "iterator on <%s>\n", obj);
01115 ao2_t_ref(obj, -1,"test");
01116 }
01117 ao2_iterator_destroy(&ai);
01118 }
01119 ast_cli(a->fd, "testing callbacks again\n");
01120 ao2_t_callback(c1, 0, print_cb, a, "test callback");
01121
01122 ast_verbose("now you should see an error message:\n");
01123 ao2_t_ref(&i, -1, "");
01124
01125 ast_cli(a->fd, "destroy container\n");
01126 ao2_t_ref(c1, -1, "");
01127 handle_astobj2_stats(e, CLI_HANDLER, &fake_args);
01128 return CLI_SUCCESS;
01129 }
01130
01131 static struct ast_cli_entry cli_astobj2[] = {
01132 AST_CLI_DEFINE(handle_astobj2_stats, "Print astobj2 statistics"),
01133 AST_CLI_DEFINE(handle_astobj2_test, "Test astobj2"),
01134 };
01135 #endif
01136
01137 static void astobj2_cleanup(void)
01138 {
01139 #ifdef AO2_DEBUG
01140 ast_cli_unregister_multiple(cli_astobj2, ARRAY_LEN(cli_astobj2));
01141 #endif
01142
01143 #ifdef REF_DEBUG
01144 fclose(ref_log);
01145 ref_log = NULL;
01146 #endif
01147 }
01148
01149
01150 int astobj2_init(void)
01151 {
01152 #ifdef REF_DEBUG
01153 char ref_filename[1024];
01154 #endif
01155
01156 #ifdef REF_DEBUG
01157 snprintf(ref_filename, sizeof(ref_filename), "%s/refs", ast_config_AST_LOG_DIR);
01158 ref_log = fopen(ref_filename, "w");
01159 if (!ref_log) {
01160 ast_log(LOG_ERROR, "Could not open ref debug log file: %s\n", ref_filename);
01161 }
01162 #endif
01163
01164 #ifdef AO2_DEBUG
01165 ast_cli_register_multiple(cli_astobj2, ARRAY_LEN(cli_astobj2));
01166 #endif
01167
01168 ast_register_atexit(astobj2_cleanup);
01169 return 0;
01170 }