dbus/dbus-dataslot.c

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