Changeset 184 for trunk/lib


Ignore:
Timestamp:
03/20/10 13:50:44 (15 years ago)
Author:
tim
Message:

redesigned memory management to allow for multiple references to talloc-ed objects

Location:
trunk/lib
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/lib/lru_cache.c

    r169 r184  
    119119  if(max_keys == 0)
    120120    ret_val->num_buckets = 1024;
     121  else if(max_keys == 1)
     122    ret_val->num_buckets = 1;   
    121123  else
    122124  {
    … …  
    125127      ret_val->num_buckets = 1;
    126128  }
    127 
     129 
    128130  ret_val->table = talloc_array(ret_val,
    129131                                lru_cache_element*, ret_val->num_buckets);
    … …  
    177179     */
    178180    if(ht->talloc_data)
    179       talloc_free(e->data);
     181      talloc_unlink(e, e->data);
    180182
    181183    if(e->newer == NULL)
    … …  
    224226
    225227      if(ht->talloc_data)
    226         talloc_free(e->data);
     228        talloc_unlink(e, e->data);
    227229
    228230      tmp_index = talloc_realloc_size(e, e->index, index_len);
    … …  
    261263  e->data = data;
    262264  if(ht->talloc_data)
    263     talloc_steal(e, e->data);
     265    talloc_reference(e, e->data);
    264266
    265267  /* Finally, let's insert the element to the newest position in the LRU list.*/

  • trunk/lib/regfi.c

    r182 r184  
    947947 
    948948  for(i=0; i < num_lists; i++)
    949     regfi_subkeylist_free(lists[i]);
     949    talloc_free(lists[i]);
    950950  free(lists);
    951951
    … …  
    11851185    if(vk->valuename == NULL)
    11861186    {
    1187       regfi_free_value(vk);
     1187      talloc_free(vk);
    11881188      return;
    11891189    }
    … …  
    12791279    if(nk->keyname == NULL)
    12801280    {
    1281       regfi_free_key(nk);
     1281      talloc_free(nk);
    12821282      return;
    12831283    }
    … …  
    13331333      if(strict)
    13341334      {
    1335         regfi_free_key(nk);
     1335        talloc_free(nk);
    13361336        return NULL;
    13371337      }
    … …  
    13501350        if(strict)
    13511351        {
    1352           regfi_free_key(nk);
     1352          talloc_free(nk);
    13531353          return NULL;
    13541354        }
    … …  
    13671367      if(strict)
    13681368      {
    1369         regfi_free_key(nk);
     1369        talloc_free(nk);
    13701370        return NULL;
    13711371      }
    … …  
    14001400  void* failure_ptr = NULL;
    14011401 
     1402  max_size = regfi_calc_maxsize(file, offset);
     1403  if(max_size < 0)
     1404    return NULL;
     1405
     1406  if(file->sk_cache == NULL)
     1407    return regfi_parse_sk(file, offset, max_size, strict);
     1408
    14021409  if(!regfi_lock(file, file->sk_lock, "regfi_load_sk"))
    14031410    return NULL;
    … …  
    14121419  if(ret_val == NULL)
    14131420  {
    1414     max_size = regfi_calc_maxsize(file, offset);
    1415     if(max_size < 0)
    1416       return NULL;
    1417 
    14181421    ret_val = regfi_parse_sk(file, offset, max_size, strict);
    14191422    if(ret_val == NULL)
    … …  
    14241427      *(uint32_t*)failure_ptr = REGFI_OFFSET_NONE;
    14251428      lru_cache_update(file->sk_cache, &offset, 4, failure_ptr);
     1429
     1430      /* Let the cache be the only owner of this */
     1431      talloc_unlink(NULL, failure_ptr);
    14261432      return NULL;
    14271433    }
    1428 
    1429     lru_cache_update(file->sk_cache, &offset, 4, ret_val);
    14301434  }
    14311435
    14321436  if(!regfi_unlock(file, file->sk_lock, "regfi_load_sk"))
    1433     return NULL;
     1437  {
     1438    talloc_unlink(NULL, ret_val);
     1439    return NULL;
     1440  }
    14341441
    14351442  return ret_val;
    … …  
    15971604  cache_secret = 0x15DEAD05^time(NULL)^(getpid()<<16);
    15981605
    1599   /* Cache an unlimited number of SK records.  Typically there are very few. */
    1600   rb->sk_cache = lru_cache_create_ctx(rb, 0, cache_secret, true);
     1606  if(REGFI_CACHE_SK)
     1607    rb->sk_cache = lru_cache_create_ctx(rb, 64, cache_secret, true);
     1608  else
     1609    rb->sk_cache = NULL;
    16011610
    16021611  /* success */
    … …  
    16781687/******************************************************************************
    16791688 *****************************************************************************/
    1680 void regfi_free_key(REGFI_NK_REC* nk)
    1681 {
    1682   regfi_subkeylist_free(nk->subkeys);
    1683   talloc_free(nk);
    1684 }
    1685 
    1686 
    1687 /******************************************************************************
    1688  *****************************************************************************/
    1689 void regfi_free_value(REGFI_VK_REC* vk)
    1690 {
    1691   talloc_free(vk);
    1692 }
    1693 
    1694 
    1695 /******************************************************************************
    1696  *****************************************************************************/
    1697 void regfi_subkeylist_free(REGFI_SUBKEY_LIST* list)
    1698 {
    1699   if(list != NULL)
    1700   {
    1701     talloc_free(list);
    1702   }
    1703 }
     1689void regfi_free_record(const void* record)
     1690{
     1691  talloc_unlink(NULL, (void*)record);
     1692}
     1693
    17041694
    17051695
    … …  
    17311721  }
    17321722  ret_val->cur_key = root;
    1733   talloc_steal(ret_val, root);
     1723  talloc_reference(ret_val, root);
    17341724
    17351725  ret_val->key_positions = void_stack_new(REGFI_MAX_DEPTH);
    … …  
    17831773  {
    17841774    talloc_free(pos);
    1785     regfi_free_key(subkey);
     1775    talloc_unlink(NULL, subkey);
    17861776    return false;
    17871777  }
    1788   talloc_steal(i, subkey);
     1778  talloc_reference(i, subkey);
    17891779
    17901780  i->cur_key = subkey;
    … …  
    18061796    return false;
    18071797
    1808   regfi_free_key(i->cur_key);
     1798  talloc_unlink(i, i->cur_key);
    18091799  i->cur_key = pos->nk;
    18101800  i->cur_subkey = pos->cur_subkey;
    … …  
    18471837    else
    18481838    {
    1849       regfi_free_key(subkey);
     1839      talloc_unlink(NULL, subkey);
    18501840      subkey = (REGFI_NK_REC*)regfi_iterator_next_subkey(i);
    18511841    }
    … …  
    18581848  }
    18591849
    1860   regfi_free_key(subkey);
     1850  talloc_unlink(NULL, subkey);
    18611851  return true;
    18621852}
    … …  
    19091899/******************************************************************************
    19101900 *****************************************************************************/
    1911 REGFI_NK_REC* regfi_iterator_first_subkey(REGFI_ITERATOR* i)
     1901const REGFI_NK_REC* regfi_iterator_first_subkey(REGFI_ITERATOR* i)
    19121902{
    19131903  i->cur_subkey = 0;
    … …  
    19181908/******************************************************************************
    19191909 *****************************************************************************/
    1920 REGFI_NK_REC* regfi_iterator_cur_subkey(REGFI_ITERATOR* i)
     1910const REGFI_NK_REC* regfi_iterator_cur_subkey(REGFI_ITERATOR* i)
    19211911{
    19221912  uint32_t nk_offset;
    … …  
    19291919  nk_offset = i->cur_key->subkeys->elements[i->cur_subkey].offset;
    19301920
    1931   return regfi_load_key(i->f, nk_offset+REGFI_REGF_SIZE, i->string_encoding,
    1932                         true);
     1921  return regfi_load_key(i->f, nk_offset+REGFI_REGF_SIZE,
     1922                        i->string_encoding, true);
    19331923}
    19341924
    … …  
    19371927 *****************************************************************************/
    19381928/* XXX: some way of indicating reason for failure should be added. */
    1939 REGFI_NK_REC* regfi_iterator_next_subkey(REGFI_ITERATOR* i)
    1940 {
    1941   REGFI_NK_REC* subkey;
     1929const REGFI_NK_REC* regfi_iterator_next_subkey(REGFI_ITERATOR* i)
     1930{
     1931  const REGFI_NK_REC* subkey;
    19421932
    19431933  i->cur_subkey++;
    … …  
    19551945bool regfi_iterator_find_value(REGFI_ITERATOR* i, const char* value_name)
    19561946{
    1957   REGFI_VK_REC* cur;
     1947  const REGFI_VK_REC* cur;
    19581948  bool found = false;
    19591949  uint32_t old_value = i->cur_value;
    … …  
    19731963    else
    19741964    {
    1975       regfi_free_value(cur);
     1965      regfi_free_record(cur);
    19761966      cur = regfi_iterator_next_value(i);
    19771967    }
    … …  
    19841974  }
    19851975
    1986   regfi_free_value(cur);
     1976  regfi_free_record(cur);
    19871977  return true;
    19881978}
    … …  
    19911981/******************************************************************************
    19921982 *****************************************************************************/
    1993 REGFI_VK_REC* regfi_iterator_first_value(REGFI_ITERATOR* i)
     1983const REGFI_VK_REC* regfi_iterator_first_value(REGFI_ITERATOR* i)
    19941984{
    19951985  i->cur_value = 0;
    … …  
    20001990/******************************************************************************
    20011991 *****************************************************************************/
    2002 REGFI_VK_REC* regfi_iterator_cur_value(REGFI_ITERATOR* i)
     1992const REGFI_VK_REC* regfi_iterator_cur_value(REGFI_ITERATOR* i)
    20031993{
    20041994  REGFI_VK_REC* ret_val = NULL;
    … …  
    20212011/******************************************************************************
    20222012 *****************************************************************************/
    2023 REGFI_VK_REC* regfi_iterator_next_value(REGFI_ITERATOR* i)
    2024 {
    2025   REGFI_VK_REC* ret_val;
     2013const REGFI_VK_REC* regfi_iterator_next_value(REGFI_ITERATOR* i)
     2014{
     2015  const REGFI_VK_REC* ret_val;
    20262016
    20272017  i->cur_value++;
    … …  
    20362026/******************************************************************************
    20372027 *****************************************************************************/
    2038 REGFI_CLASSNAME* regfi_iterator_fetch_classname(REGFI_ITERATOR* i,
    2039                                                 const REGFI_NK_REC* key)
     2028const REGFI_CLASSNAME* regfi_iterator_fetch_classname(REGFI_ITERATOR* i,
     2029                                                      const REGFI_NK_REC* key)
    20402030{
    20412031  REGFI_CLASSNAME* ret_val;
    … …  
    21002090/******************************************************************************
    21012091 *****************************************************************************/
    2102 REGFI_DATA* regfi_iterator_fetch_data(REGFI_ITERATOR* i,
    2103                                       const REGFI_VK_REC* value)
     2092const REGFI_DATA* regfi_iterator_fetch_data(REGFI_ITERATOR* i,
     2093                                            const REGFI_VK_REC* value)
    21042094{
    21052095  REGFI_DATA* ret_val = NULL;
    … …  
    21402130 
    21412131  return ret_val;
    2142 }
    2143 
    2144 
    2145 /******************************************************************************
    2146  *****************************************************************************/
    2147 void regfi_free_classname(REGFI_CLASSNAME* classname)
    2148 {
    2149   talloc_free(classname);
    2150 }
    2151 
    2152 /******************************************************************************
    2153  *****************************************************************************/
    2154 void regfi_free_data(REGFI_DATA* data)
    2155 {
    2156   talloc_free(data);
    21572132}
    21582133
Note: See TracChangeset for help on using the changeset viewer.