1 /* -*- mode: C; c-file-style: "gnu" -*- */ 2 /* dbus-dataslot.c storing data on objects 3 * 4 * Copyright (C) 2003 Red Hat, Inc. 5 * 6 * Licensed under the Academic Free License version 2.1 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 21 * 22 */ 23 #include "dbus-dataslot.h" 24 #include "dbus-threads-internal.h" 25 26 /** 27 * @defgroup DBusDataSlot Data slots 28 * @ingroup DBusInternals 29 * @brief Storing data by ID 30 * 31 * Types and functions related to storing data by an 32 * allocated ID. This is used for dbus_connection_set_data(), 33 * dbus_server_set_data(), etc. 34 * @{ 35 */ 36 37 /** 38 * Initializes a data slot allocator object, used to assign 39 * integer IDs for data slots. 40 * 41 * @param allocator the allocator to initialize 42 */ 43 dbus_bool_t 44 _dbus_data_slot_allocator_init (DBusDataSlotAllocator *allocator) 45 { 46 allocator->allocated_slots = NULL; 47 allocator->n_allocated_slots = 0; 48 allocator->n_used_slots = 0; 49 allocator->lock_loc = NULL; 50 51 return TRUE; 52 } 53 54 /** 55 * Allocates an integer ID to be used for storing data 56 * in a #DBusDataSlotList. If the value at *slot_id_p is 57 * not -1, this function just increments the refcount for 58 * the existing slot ID. If the value is -1, a new slot ID 59 * is allocated and stored at *slot_id_p. 60 * 61 * @param allocator the allocator 62 * @param mutex_loc the location lock for this allocator 63 * @param slot_id_p address to fill with the slot ID 64 * @returns #TRUE on success 65 */ 66 dbus_bool_t 67 _dbus_data_slot_allocator_alloc (DBusDataSlotAllocator *allocator, 68 DBusMutex **mutex_loc, 69 dbus_int32_t *slot_id_p) 70 { 71 dbus_int32_t slot; 72 73 _dbus_mutex_lock (*mutex_loc); 74 75 if (allocator->n_allocated_slots == 0) 76 { 77 _dbus_assert (allocator->lock_loc == NULL); 78 allocator->lock_loc = mutex_loc; 79 } 80 else if (allocator->lock_loc != mutex_loc) 81 { 82 _dbus_warn_check_failed ("D-Bus threads were initialized after first using the D-Bus library. If your application does not directly initialize threads or use D-Bus, keep in mind that some library or plugin may have used D-Bus or initialized threads behind your back. You can often fix this problem by calling dbus_init_threads() or dbus_g_threads_init() early in your main() method, before D-Bus is used.\n"); 83 _dbus_assert_not_reached ("exiting"); 84 } 85 86 if (*slot_id_p >= 0) 87 { 88 slot = *slot_id_p; 89 90 _dbus_assert (slot < allocator->n_allocated_slots); 91 _dbus_assert (allocator->allocated_slots[slot].slot_id == slot); 92 93 allocator->allocated_slots[slot].refcount += 1; 94 95 goto out; 96 } 97 98 _dbus_assert (*slot_id_p < 0); 99 100 if (allocator->n_used_slots < allocator->n_allocated_slots) 101 { 102 slot = 0; 103 while (slot < allocator->n_allocated_slots) 104 { 105 if (allocator->allocated_slots[slot].slot_id < 0) 106 { 107 allocator->allocated_slots[slot].slot_id = slot; 108 allocator->allocated_slots[slot].refcount = 1; 109 allocator->n_used_slots += 1; 110 break; 111 } 112 ++slot; 113 } 114 115 _dbus_assert (slot < allocator->n_allocated_slots); 116 } 117 else 118 { 119 DBusAllocatedSlot *tmp; 120 121 slot = -1; 122 tmp = dbus_realloc (allocator->allocated_slots, 123 sizeof (DBusAllocatedSlot) * (allocator->n_allocated_slots + 1)); 124 if (tmp == NULL) 125 goto out; 126 127 allocator->allocated_slots = tmp; 128 slot = allocator->n_allocated_slots; 129 allocator->n_allocated_slots += 1; 130 allocator->n_used_slots += 1; 131 allocator->allocated_slots[slot].slot_id = slot; 132 allocator->allocated_slots[slot].refcount = 1; 133 } 134 135 _dbus_assert (slot >= 0); 136 _dbus_assert (slot < allocator->n_allocated_slots); 137 _dbus_assert (*slot_id_p < 0); 138 _dbus_assert (allocator->allocated_slots[slot].slot_id == slot); 139 _dbus_assert (allocator->allocated_slots[slot].refcount == 1); 140 141 *slot_id_p = slot; 142 143 _dbus_verbose ("Allocated slot %d on allocator %p total %d slots allocated %d used\n", 144 slot, allocator, allocator->n_allocated_slots, allocator->n_used_slots); 145 146 out: 147 _dbus_mutex_unlock (*(allocator->lock_loc)); 148 return slot >= 0; 149 } 150 151 /** 152 * Deallocates an ID previously allocated with 153 * _dbus_data_slot_allocator_alloc(). Existing data stored on 154 * existing #DBusDataSlotList objects with this ID will be freed when the 155 * data list is finalized, but may not be retrieved (and may only be 156 * replaced if someone else reallocates the slot). 157 * The slot value is reset to -1 if this is the last unref. 158 * 159 * @param allocator the allocator 160 * @param slot_id_p address where we store the slot 161 */ 162 void 163 _dbus_data_slot_allocator_free (DBusDataSlotAllocator *allocator, 164 dbus_int32_t *slot_id_p) 165 { 166 _dbus_mutex_lock (*(allocator->lock_loc)); 167 168 _dbus_assert (*slot_id_p < allocator->n_allocated_slots); 169 _dbus_assert (allocator->allocated_slots[*slot_id_p].slot_id == *slot_id_p); 170 _dbus_assert (allocator->allocated_slots[*slot_id_p].refcount > 0); 171 172 allocator->allocated_slots[*slot_id_p].refcount -= 1; 173 174 if (allocator->allocated_slots[*slot_id_p].refcount > 0) 175 { 176 _dbus_mutex_unlock (*(allocator->lock_loc)); 177 return; 178 } 179 180 /* refcount is 0, free the slot */ 181 _dbus_verbose ("Freeing slot %d on allocator %p total %d allocated %d used\n", 182 *slot_id_p, allocator, allocator->n_allocated_slots, allocator->n_used_slots); 183 184 allocator->allocated_slots[*slot_id_p].slot_id = -1; 185 *slot_id_p = -1; 186 187 allocator->n_used_slots -= 1; 188 189 if (allocator->n_used_slots == 0) 190 { 191 DBusMutex **mutex_loc = allocator->lock_loc; 192 193 dbus_free (allocator->allocated_slots); 194 allocator->allocated_slots = NULL; 195 allocator->n_allocated_slots = 0; 196 allocator->lock_loc = NULL; 197 198 _dbus_mutex_unlock (*mutex_loc); 199 } 200 else 201 { 202 _dbus_mutex_unlock (*(allocator->lock_loc)); 203 } 204 } 205 206 /** 207 * Initializes a slot list. 208 * @param list the list to initialize. 209 */ 210 void 211 _dbus_data_slot_list_init (DBusDataSlotList *list) 212 { 213 list->slots = NULL; 214 list->n_slots = 0; 215 } 216 217 /** 218 * Stores a pointer in the data slot list, along with an optional 219 * function to be used for freeing the data when the data is set 220 * again, or when the slot list is finalized. The slot number must 221 * have been allocated with _dbus_data_slot_allocator_alloc() for the 222 * same allocator passed in here. The same allocator has to be used 223 * with the slot list every time. 224 * 225 * @param allocator the allocator to use 226 * @param list the data slot list 227 * @param slot the slot number 228 * @param data the data to store 229 * @param free_data_func finalizer function for the data 230 * @param old_free_func free function for any previously-existing data 231 * @param old_data previously-existing data, should be freed with old_free_func 232 * @returns #TRUE if there was enough memory to store the data 233 */ 234 dbus_bool_t 235 _dbus_data_slot_list_set (DBusDataSlotAllocator *allocator, 236 DBusDataSlotList *list, 237 int slot, 238 void *data, 239 DBusFreeFunction free_data_func, 240 DBusFreeFunction *old_free_func, 241 void **old_data) 242 { 243 #ifndef DBUS_DISABLE_ASSERT 244 /* We need to take the allocator lock here, because the allocator could 245 * be e.g. realloc()ing allocated_slots. We avoid doing this if asserts 246 * are disabled, since then the asserts are empty. 247 */ 248 _dbus_mutex_lock (*(allocator->lock_loc)); 249 _dbus_assert (slot < allocator->n_allocated_slots); 250 _dbus_assert (allocator->allocated_slots[slot].slot_id == slot); 251 _dbus_mutex_unlock (*(allocator->lock_loc)); 252 #endif 253 254 if (slot >= list->n_slots) 255 { 256 DBusDataSlot *tmp; 257 int i; 258 259 tmp = dbus_realloc (list->slots, 260 sizeof (DBusDataSlot) * (slot + 1)); 261 if (tmp == NULL) 262 return FALSE; 263 264 list->slots = tmp; 265 i = list->n_slots; 266 list->n_slots = slot + 1; 267 while (i < list->n_slots) 268 { 269 list->slots[i].data = NULL; 270 list->slots[i].free_data_func = NULL; 271 ++i; 272 } 273 } 274 275 _dbus_assert (slot < list->n_slots); 276 277 *old_data = list->slots[slot].data; 278 *old_free_func = list->slots[slot].free_data_func; 279 280 list->slots[slot].data = data; 281 list->slots[slot].free_data_func = free_data_func; 282 283 return TRUE; 284 } 285 286 /** 287 * Retrieves data previously set with _dbus_data_slot_list_set_data(). 288 * The slot must still be allocated (must not have been freed). 289 * 290 * @param allocator the allocator slot was allocated from 291 * @param list the data slot list 292 * @param slot the slot to get data from 293 * @returns the data, or #NULL if not found 294 */ 295 void* 296 _dbus_data_slot_list_get (DBusDataSlotAllocator *allocator, 297 DBusDataSlotList *list, 298 int slot) 299 { 300 #ifndef DBUS_DISABLE_ASSERT 301 /* We need to take the allocator lock here, because the allocator could 302 * be e.g. realloc()ing allocated_slots. We avoid doing this if asserts 303 * are disabled, since then the asserts are empty. 304 */ 305 _dbus_mutex_lock (*(allocator->lock_loc)); 306 _dbus_assert (slot >= 0); 307 _dbus_assert (slot < allocator->n_allocated_slots); 308 _dbus_assert (allocator->allocated_slots[slot].slot_id == slot); 309 _dbus_mutex_unlock (*(allocator->lock_loc)); 310 #endif 311 312 if (slot >= list->n_slots) 313 return NULL; 314 else 315 return list->slots[slot].data; 316 } 317 318 /** 319 * Frees all data slots contained in the list, calling 320 * application-provided free functions if they exist. 321 * 322 * @param list the list to clear 323 */ 324 void 325 _dbus_data_slot_list_clear (DBusDataSlotList *list) 326 { 327 int i; 328 329 i = 0; 330 while (i < list->n_slots) 331 { 332 if (list->slots[i].free_data_func) 333 (* list->slots[i].free_data_func) (list->slots[i].data); 334 list->slots[i].data = NULL; 335 list->slots[i].free_data_func = NULL; 336 ++i; 337 } 338 } 339 340 /** 341 * Frees the data slot list and all data slots contained 342 * in it, calling application-provided free functions 343 * if they exist. 344 * 345 * @param list the list to free 346 */ 347 void 348 _dbus_data_slot_list_free (DBusDataSlotList *list) 349 { 350 _dbus_data_slot_list_clear (list); 351 352 dbus_free (list->slots); 353 list->slots = NULL; 354 list->n_slots = 0; 355 } 356 357 /** @} */ 358 359 #ifdef DBUS_BUILD_TESTS 360 #include "dbus-test.h" 361 #include <stdio.h> 362 363 static int free_counter; 364 365 static void 366 test_free_slot_data_func (void *data) 367 { 368 int i = _DBUS_POINTER_TO_INT (data); 369 370 _dbus_assert (free_counter == i); 371 ++free_counter; 372 } 373 374 /** 375 * Test function for data slots 376 */ 377 dbus_bool_t 378 _dbus_data_slot_test (void) 379 { 380 DBusDataSlotAllocator allocator; 381 DBusDataSlotList list; 382 int i; 383 DBusFreeFunction old_free_func; 384 void *old_data; 385 DBusMutex *mutex; 386 387 if (!_dbus_data_slot_allocator_init (&allocator)) 388 _dbus_assert_not_reached ("no memory for allocator"); 389 390 _dbus_data_slot_list_init (&list); 391 392 _dbus_mutex_new_at_location (&mutex); 393 if (mutex == NULL) 394 _dbus_assert_not_reached ("failed to alloc mutex"); 395 396 #define N_SLOTS 100 397 398 i = 0; 399 while (i < N_SLOTS) 400 { 401 /* we don't really want apps to rely on this ordered 402 * allocation, but it simplifies things to rely on it 403 * here. 404 */ 405 dbus_int32_t tmp = -1; 406 407 _dbus_data_slot_allocator_alloc (&allocator, &mutex, &tmp); 408 409 if (tmp != i) 410 _dbus_assert_not_reached ("did not allocate slots in numeric order\n"); 411 412 ++i; 413 } 414 415 i = 0; 416 while (i < N_SLOTS) 417 { 418 if (!_dbus_data_slot_list_set (&allocator, &list, 419 i, 420 _DBUS_INT_TO_POINTER (i), 421 test_free_slot_data_func, 422 &old_free_func, &old_data)) 423 _dbus_assert_not_reached ("no memory to set data"); 424 425 _dbus_assert (old_free_func == NULL); 426 _dbus_assert (old_data == NULL); 427 428 _dbus_assert (_dbus_data_slot_list_get (&allocator, &list, i) == 429 _DBUS_INT_TO_POINTER (i)); 430 431 ++i; 432 } 433 434 free_counter = 0; 435 i = 0; 436 while (i < N_SLOTS) 437 { 438 if (!_dbus_data_slot_list_set (&allocator, &list, 439 i, 440 _DBUS_INT_TO_POINTER (i), 441 test_free_slot_data_func, 442 &old_free_func, &old_data)) 443 _dbus_assert_not_reached ("no memory to set data"); 444 445 _dbus_assert (old_free_func == test_free_slot_data_func); 446 _dbus_assert (_DBUS_POINTER_TO_INT (old_data) == i); 447 448 (* old_free_func) (old_data); 449 _dbus_assert (i == (free_counter - 1)); 450 451 _dbus_assert (_dbus_data_slot_list_get (&allocator, &list, i) == 452 _DBUS_INT_TO_POINTER (i)); 453 454 ++i; 455 } 456 457 free_counter = 0; 458 _dbus_data_slot_list_free (&list); 459 460 _dbus_assert (N_SLOTS == free_counter); 461 462 i = 0; 463 while (i < N_SLOTS) 464 { 465 dbus_int32_t tmp = i; 466 467 _dbus_data_slot_allocator_free (&allocator, &tmp); 468 _dbus_assert (tmp == -1); 469 ++i; 470 } 471 472 _dbus_mutex_free_at_location (&mutex); 473 474 return TRUE; 475 } 476 477 #endif /* DBUS_BUILD_TESTS */ 478
