~ubuntu-branches/debian/jessie/389-ds-base/jessie

    cache->c_lruhead = cache->c_lrutail = NULL;

    cache_make_hashes(cache, type);

 

       return 0;

    }

    LDAPDebug(LDAP_DEBUG_TRACE, "<= cache_init\n", 0, 0, 0);

 

void cache_clear(struct cache *cache, int type)

{

    if (CACHE_TYPE_ENTRY == type) {

        entrycache_clear_int(cache);

    } else if (CACHE_TYPE_DN == type) {

        dncache_clear_int(cache);

    }

}

 

static void erase_cache(struct cache *cache, int type)

    slapi_counter_destroy(&cache->c_cursize);

    slapi_counter_destroy(&cache->c_hits);

    slapi_counter_destroy(&cache->c_tries);

    PR_DestroyLock(cache->c_emutexalloc_mutex);

}

 

                "WARNING -- Minimum cache size is %lu -- rounding up\n",

                MINCACHESIZE, 0, 0);

    }

    cache->c_maxsize = bytes;

    LOG("entry cache size set to %lu\n", bytes, 0, 0);

    /* check for full cache, and clear out if necessary */

       erase_cache(cache, CACHE_TYPE_ENTRY);

       cache_make_hashes(cache, CACHE_TYPE_ENTRY);

    }

    if (! dblayer_is_cachesize_sane(&bytes)) {

       LDAPDebug(LDAP_DEBUG_ANY,

                "WARNING -- Possible CONFIGURATION ERROR -- cachesize "

     * was given in # entries instead of memory footprint.  hopefully,

     * we can eventually drop this.

     */

    cache->c_maxentries = entries;

    if (entries >= 0) {

        LOG("entry cache entry-limit set to %lu\n", entries, 0, 0);

    /* check for full cache, and clear out if necessary */

    if (CACHE_FULL(cache))

        eflush = entrycache_flush(cache);

    while (eflush)

    {

        eflushtemp = BACK_LRU_NEXT(eflush, struct backentry *);

{

    size_t n = 0;

 

    n = cache->c_maxsize;

    return n;

}

 

{

    long n;

 

    n = cache->c_maxentries;

    return n;

}

 

                     long *nentries, long *maxentries,

                     size_t *size, size_t *maxsize)

{

    if (hits) *hits = slapi_counter_get_value(cache->c_hits);

    if (tries) *tries = slapi_counter_get_value(cache->c_tries);

    if (nentries) *nentries = cache->c_curentries;

    if (maxentries) *maxentries = cache->c_maxentries;

    if (size) *size = slapi_counter_get_value(cache->c_cursize);

    if (maxsize) *maxsize = cache->c_maxsize;

}

 

void cache_debug_hash(struct cache *cache, char **out)

    Hashtable *ht = NULL;

    char *name = "unknown";

 

    *out = (char *)slapi_ch_malloc(1024);

    **out = 0;

 

            sprintf(*out + strlen(*out), "%d[%d] ", j, slot_stats[j]);

        slapi_ch_free((void **)&slot_stats);

    }

}

 

 

    }

    e = (struct backcommon *)ptr;

 

    if (CACHE_TYPE_ENTRY == e->ep_type) {

        ASSERT(e->ep_refcnt > 0);

        ret = entrycache_remove_int(cache, (struct backentry *)e);

    } else if (CACHE_TYPE_DN == e->ep_type) {

        ret = dncache_remove_int(cache, (struct backdn *)e);

    }

    return ret;

}

 

#endif

    newndn = slapi_sdn_get_ndn(backentry_get_sdn(newe));

    entry_size = cache_entry_size(newe);

 

    /*

     * First, remove the old entry from all the hashtables.

    }

    /* If fails, we have to make sure the both entires are removed from the cache,

     * otherwise, we have no idea what's left in the cache or not... */

        /* if we're doing a modrdn or turning an entry to a tombstone,

         * the new entry can be in the dn table already, so we need to remove that too.

         */

        {

            slapi_counter_subtract(cache->c_cursize, newe->ep_size);

            cache->c_curentries--;

            LOG("entry cache replace remove entry size %lu\n", newe->ep_size, 0, 0);

        }

    }

            LOG("entry cache replace (%s): cache index tables out of sync - found dn [%d] id [%d]\n",

                oldndn, found_in_dn, found_in_id);

#endif

            return 1;

        }

    }

     * tested enough that we believe it works.)

     */

    if (!add_hash(cache->c_dntable, (void *)newndn, strlen(newndn), newe, (void **)&alte)) {

    }

    if (!add_hash(cache->c_idtable, &(newe->ep_id), sizeof(ID), newe, (void **)&alte)) {

    }

#ifdef UUIDCACHE_ON 

    if (newuuid && !add_hash(cache->c_uuidtable, (void *)newuuid, strlen(newuuid),

                       newe, NULL)) {

    }

#endif

    /* adjust cache meta info */

        slapi_counter_subtract(cache->c_cursize, olde->ep_size - newe->ep_size);

    }

    newe->ep_state = 0;

    LOG("<= entrycache_replace OK,  cache size now %lu cache count now %ld\n",

             slapi_counter_get_value(cache->c_cursize), cache->c_curentries, 0);

    return 0;

    struct backentry *e;

 

    e = *bep;

    LOG("=> entrycache_return (%s) entry count: %d, entry in cache:%ld\n",

                    backentry_get_ndn(e), e->ep_refcnt, cache->c_curentries);

 

    if (e->ep_state & ENTRY_STATE_NOTINCACHE)

    {

        backentry_free(bep);

            }

        }

    }

    while (eflush)

    {

        eflushtemp = BACK_LRU_NEXT(eflush, struct backentry *);

    LOG("=> cache_find_dn (%s)\n", dn, 0, 0);

 

    /*entry normalized by caller (dn2entry.c)  */

    if (find_hash(cache->c_dntable, (void *)dn, ndnlen, (void **)&e)) {

       /* need to check entry state */

       if (e->ep_state != 0) {

           /* entry is deleted or not fully created yet */

           LOG("<= cache_find_dn (NOT FOUND)\n", 0, 0, 0);

           return NULL;

       }

       if (e->ep_refcnt == 0)

           lru_delete(cache, (void *)e);

       e->ep_refcnt++;

       slapi_counter_increment(cache->c_hits);

    } else {

    }

    slapi_counter_increment(cache->c_tries);

 

 

    LOG("=> cache_find_id (%lu)\n", (u_long)id, 0, 0);

 

    if (find_hash(cache->c_idtable, &id, sizeof(ID), (void **)&e)) {

       /* need to check entry state */

       if (e->ep_state != 0) {

           /* entry is deleted or not fully created yet */

           LOG("<= cache_find_id (NOT FOUND)\n", 0, 0, 0);

           return NULL;

       }

       if (e->ep_refcnt == 0)

           lru_delete(cache, (void *)e);

       e->ep_refcnt++;

       slapi_counter_increment(cache->c_hits);

    } else {

    }

    slapi_counter_increment(cache->c_tries);

 

 

    LOG("=> cache_find_uuid (%s)\n", uuid, 0, 0);

 

    if (find_hash(cache->c_uuidtable, uuid, strlen(uuid), (void **)&e)) {

       /* need to check entry state */

       if (e->ep_state != 0) {

           /* entry is deleted or not fully created yet */

           LOG("<= cache_find_uuid (NOT FOUND)\n", 0, 0, 0);

           return NULL;

       }

       if (e->ep_refcnt == 0)

           lru_delete(cache, (void *)e);

       e->ep_refcnt++;

       slapi_counter_increment(cache->c_hits);

    } else {

    }

    slapi_counter_increment(cache->c_tries);

 

        entry_size = e->ep_size;

    }

 

    if (! add_hash(cache->c_dntable, (void *)ndn, strlen(ndn), e,

           (void **)&my_alt)) {

        LOG("entry \"%s\" already in dn cache\n", ndn, 0, 0);

                 * to prevent that the caller accidentally thinks the existing

                 * entry is not the same one the caller has and releases it.

                 */

                return 1;

            }

        }

            {

                LOG("the entry %s is reserved (ep_state: 0x%x, state: 0x%x)\n", ndn, e->ep_state, state);

                e->ep_state |= ENTRY_STATE_NOTINCACHE;

                return -1;

            }

            else if (state != 0)

                LOG("the entry %s already exists. cannot reserve it. (ep_state: 0x%x, state: 0x%x)\n",

                    ndn, e->ep_state, state);

                e->ep_state |= ENTRY_STATE_NOTINCACHE;

                return -1;

            }

            else

                    (*alt)->ep_refcnt++;

                    LOG("the entry %s already exists.  returning existing entry %s (state: 0x%x)\n",

                        ndn, backentry_get_ndn(my_alt), state);

                } else {

                    LOG("the entry %s already exists.  Not returning existing entry %s (state: 0x%x)\n",

                        ndn, backentry_get_ndn(my_alt), state);

                }

            }

        }

    }

                 * fine (i think).

                 */

                LOG("<= entrycache_add_int (ignoring)\n", 0, 0, 0);

                return 0;

            }

            if(remove_hash(cache->c_dntable, (void *)ndn, strlen(ndn)) == 0){

                LOG("entrycache_add_int: failed to remove %s from dn table\n", 0, 0, 0);

            }

            e->ep_state |= ENTRY_STATE_NOTINCACHE;

            LOG("entrycache_add_int: failed to add %s to cache (ep_state: %x, already_in: %d)\n",

                ndn, e->ep_state, already_in);

            return -1;

                    LOG("entrycache_add_int: failed to remove id table(uuid cache)\n", 0, 0, 0);

                }

                e->ep_state |= ENTRY_STATE_NOTINCACHE;

                return -1;

            }

        }

        if (CACHE_FULL(cache))

            eflush = entrycache_flush(cache);

    }

 

    while (eflush)

    {

}

void cache_lock(struct cache *cache)

{

}

void cache_unlock(struct cache *cache)

{

}

 

/* locks an entry so that it can be modified (you should have gotten the

    PR_EnterMonitor(e->ep_mutexp);

 

    /* make sure entry hasn't been deleted now */

    if (e->ep_state & (ENTRY_STATE_DELETED|ENTRY_STATE_NOTINCACHE)) {

       PR_ExitMonitor(e->ep_mutexp);

       LOG("<= cache_lock_entry (DELETED)\n", 0, 0, 0);

       return RETRY_CACHE_LOCK;

    }

 

    LOG("<= cache_lock_entry (FOUND)\n", 0, 0, 0);

    return 0;

                "WARNING -- Minimum cache size is %lu -- rounding up\n",

                MINCACHESIZE, 0, 0);

    }

    cache->c_maxsize = bytes;

    LOG("entry cache size set to %lu\n", bytes, 0, 0);

    /* check for full cache, and clear out if necessary */

       erase_cache(cache, CACHE_TYPE_DN);

       cache_make_hashes(cache, CACHE_TYPE_DN);

    }

    if (! dblayer_is_cachesize_sane(&bytes)) {

       LDAPDebug1Arg(LDAP_DEBUG_ANY,

                "WARNING -- Possible CONFIGURATION ERROR -- cachesize "

    LOG("=> dncache_return (%s) reference count: %d, dn in cache:%ld\n",

      slapi_sdn_get_dn((*bdn)->dn_sdn), (*bdn)->ep_refcnt, cache->c_curentries);

 

    if ((*bdn)->ep_state & ENTRY_STATE_NOTINCACHE)

    {

        backdn_free(bdn);

            }

        }

    }

    while (dnflush)

    {

        dnflushtemp = BACK_LRU_NEXT(dnflush, struct backdn *);

 

    LOG("=> dncache_find_id (%lu)\n", (u_long)id, 0, 0);

 

    if (find_hash(cache->c_idtable, &id, sizeof(ID), (void **)&bdn)) {

       /* need to check entry state */

       if (bdn->ep_state != 0) {

           /* entry is deleted or not fully created yet */

           LOG("<= dncache_find_id (NOT FOUND)\n", 0, 0, 0);

           return NULL;

       }

       if (bdn->ep_refcnt == 0)

           lru_delete(cache, (void *)bdn);

       bdn->ep_refcnt++;

       slapi_counter_increment(cache->c_hits);

    } else {

    }

    slapi_counter_increment(cache->c_tries);

 

    LOG("=> dncache_add_int( \"%s\", %ld )\n", slapi_sdn_get_dn(bdn->dn_sdn), 

        bdn->ep_id, 0);

 

 

    if (! add_hash(cache->c_idtable, &(bdn->ep_id), sizeof(ID), bdn,

                                                           (void **)&my_alt)) {

                 * to prevent that the caller accidentally thinks the existing

                 * entry is not the same one the caller has and releases it.

                 */

                return 1;

            }

        }

            {

                LOG("the entry is reserved\n", 0, 0, 0);

                bdn->ep_state |= ENTRY_STATE_NOTINCACHE;

                return -1;

            }

            else if (state != 0)

            {

                LOG("the entry already exists. cannot reserve it.\n", 0, 0, 0);

                bdn->ep_state |= ENTRY_STATE_NOTINCACHE;

                return -1;

            }

            else

                        lru_delete(cache, (void *)*alt);

                    (*alt)->ep_refcnt++;

                }

                return 1;

            }

        }

            dnflush = dncache_flush(cache);

        }

    }

 

    while (dnflush)

    {

     * where the entry isn't in all the table yet, so we don't care if any

     * of these return errors.

     */

 

    /*

     * First, remove the old entry from the hashtable.

        found = remove_hash(cache->c_idtable, &(olddn->ep_id), sizeof(ID));

        if (!found) {

            LOG("dn cache replace: cache index tables out of sync\n", 0, 0, 0);

            return 1;

        }

    }

     */

    if (!add_hash(cache->c_idtable, &(newdn->ep_id), sizeof(ID), newdn, NULL)) {

       LOG("dn cache replace: can't add id\n", 0, 0, 0);

       return 1;

    }

    /* adjust cache meta info */

    }

    olddn->ep_state = ENTRY_STATE_DELETED;

    newdn->ep_state = 0;

    LOG("<= dncache_replace OK,  cache size now %lu cache count now %ld\n",

             slapi_counter_get_value(cache->c_cursize), cache->c_curentries, 0);

    return 0;

 

#ifdef CACHE_DEBUG

void

{

        Slapi_DN *sdn = slapi_entry_get_sdn(e->ep_entry);

        struct backentry *debug_e = cache_find_dn(cache, 

                                                  slapi_sdn_get_dn(sdn),

                                                  slapi_sdn_get_ndn_len(sdn));

        if (in_cache) {

                if (debug_e) { /* e is in cache */

                        CACHE_RETURN(cache, &debug_e);

                        if ((e != debug_e) && !(e->ep_state & ENTRY_STATE_DELETED)) {

                                                "entry 0x%p is not in dn cache but 0x%p having the same dn %s is "

                                                "although in_cache flag is set!!!\n",

                                                e, debug_e, slapi_sdn_get_dn(sdn));

                        }

                } else if (!(e->ep_state & ENTRY_STATE_DELETED)) {

                                        "%s (id %d) is not in dn cache although in_cache flag is set!!!\n",

                                        slapi_sdn_get_dn(sdn), e->ep_id);

                }

                if (debug_e) { /* e is in cache */

                        CACHE_RETURN(cache, &debug_e);

                        if ((e != debug_e) && !(e->ep_state & ENTRY_STATE_DELETED)) {

                                                "entry 0x%p is not in id cache but 0x%p having the same id %d is "

                                                "although in_cache flag is set!!!\n",

                                                e, debug_e, e->ep_id);

                        }

                } else {

                                        "%s (id %d) is not in id cache although in_cache flag is set!!!\n",

                                        slapi_sdn_get_dn(sdn), e->ep_id);

                }

                if (debug_e) { /* e is in cache */

                        CACHE_RETURN(cache, &debug_e);

                        if (e == debug_e) {

                                                "%s (id %d) is in dn cache although in_cache flag is not set!!!\n",

                                                slapi_sdn_get_dn(sdn), e->ep_id);

                        }

                if (debug_e) { /* e is in cache: bad */

                        CACHE_RETURN(cache, &debug_e);

                        if (e == debug_e) {

                                                "%s (id %d) is in id cache although in_cache flag is not set!!!\n",

                                                slapi_sdn_get_dn(sdn), e->ep_id);

                        }

        }

}

#endif