vcs.maemo.org Git - monky/blob - src/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., 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 */