Use a thread for LDIF parsing in slapadd -q

[openldap] / servers / slapd / back-bdb / idl.c

diff --git a/servers/slapd/back-bdb/idl.c b/servers/slapd/back-bdb/idl.c
index f25478ba7495881c212e3daf0d567465d6ae62f8..3a4e95efbfb2804256f62517b1d1c1d5ac487139 100644 (file)
--- a/servers/slapd/back-bdb/idl.c
+++ b/servers/slapd/back-bdb/idl.c
@@ -2,7 +2,7 @@
 /* $OpenLDAP$ */
 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
  *
- * Copyright 2000-2007 The OpenLDAP Foundation.
+ * Copyright 2000-2011 The OpenLDAP Foundation.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -22,16 +22,28 @@
 #include "back-bdb.h"
 #include "idl.h"
 
-#define IDL_MAX(x,y)   ( x > y ? x : y )
-#define IDL_MIN(x,y)   ( x < y ? x : y )
-
-#define IDL_CMP(x,y)   ( x < y ? -1 : ( x > y ? 1 : 0 ) )
-
-#define IDL_LRU_DELETE( bdb, e ) do {                                  \
-       if ( e == bdb->bi_idl_lru_head ) bdb->bi_idl_lru_head = e->idl_lru_next; \
-       if ( e == bdb->bi_idl_lru_tail ) bdb->bi_idl_lru_tail = e->idl_lru_prev; \
-       e->idl_lru_next->idl_lru_prev = e->idl_lru_prev; \
-       e->idl_lru_prev->idl_lru_next = e->idl_lru_next; \
+#define IDL_MAX(x,y)   ( (x) > (y) ? (x) : (y) )
+#define IDL_MIN(x,y)   ( (x) < (y) ? (x) : (y) )
+#define IDL_CMP(x,y)   ( (x) < (y) ? -1 : (x) > (y) )
+
+#define IDL_LRU_DELETE( bdb, e ) do { \
+       if ( (e) == (bdb)->bi_idl_lru_head ) { \
+               if ( (e)->idl_lru_next == (bdb)->bi_idl_lru_head ) { \
+                       (bdb)->bi_idl_lru_head = NULL; \
+               } else { \
+                       (bdb)->bi_idl_lru_head = (e)->idl_lru_next; \
+               } \
+       } \
+       if ( (e) == (bdb)->bi_idl_lru_tail ) { \
+               if ( (e)->idl_lru_prev == (bdb)->bi_idl_lru_tail ) { \
+                       assert( (bdb)->bi_idl_lru_head == NULL ); \
+                       (bdb)->bi_idl_lru_tail = NULL; \
+               } else { \
+                       (bdb)->bi_idl_lru_tail = (e)->idl_lru_prev; \
+               } \
+       } \
+       (e)->idl_lru_next->idl_lru_prev = (e)->idl_lru_prev; \
+       (e)->idl_lru_prev->idl_lru_next = (e)->idl_lru_next; \
 } while ( 0 )
 
 static int
@@ -96,7 +108,7 @@ unsigned bdb_idl_search( ID *ids, ID id )
         * if not found, returns first postion greater than id
         */
        unsigned base = 0;
-       unsigned cursor = 0;
+       unsigned cursor = 1;
        int val = 0;
        unsigned n = ids[0];
 
@@ -105,27 +117,26 @@ unsigned bdb_idl_search( ID *ids, ID id )
 #endif
 
        while( 0 < n ) {
-               int pivot = n >> 1;
-               cursor = base + pivot;
-               val = IDL_CMP( id, ids[cursor + 1] );
+               unsigned pivot = n >> 1;
+               cursor = base + pivot + 1;
+               val = IDL_CMP( id, ids[cursor] );
 
                if( val < 0 ) {
                        n = pivot;
 
                } else if ( val > 0 ) {
-                       base = cursor + 1;
+                       base = cursor;
                        n -= pivot + 1;
 
                } else {
-                       return cursor + 1;
+                       return cursor;
                }
        }
        
        if( val > 0 ) {
-               return cursor + 2;
-       } else {
-               return cursor + 1;
+               ++cursor;
        }
+       return cursor;
 
 #else
        /* (reverse) linear search */
@@ -158,11 +169,11 @@ int bdb_idl_insert( ID *ids, ID id )
 
        if (BDB_IDL_IS_RANGE( ids )) {
                /* if already in range, treat as a dup */
-               if (id >= BDB_IDL_FIRST(ids) && id <= BDB_IDL_LAST(ids))
+               if (id >= BDB_IDL_RANGE_FIRST(ids) && id <= BDB_IDL_RANGE_LAST(ids))
                        return -1;
-               if (id < BDB_IDL_FIRST(ids))
+               if (id < BDB_IDL_RANGE_FIRST(ids))
                        ids[1] = id;
-               else if (id > BDB_IDL_LAST(ids))
+               else if (id > BDB_IDL_RANGE_LAST(ids))
                        ids[2] = id;
                return 0;
        }
@@ -206,7 +217,7 @@ int bdb_idl_insert( ID *ids, ID id )
        return 0;
 }
 
-static int bdb_idl_delete( ID *ids, ID id )
+int bdb_idl_delete( ID *ids, ID id )
 {
        unsigned x;
 
@@ -349,6 +360,10 @@ bdb_idl_cache_put(
        ldap_pvt_thread_mutex_lock( &bdb->bi_idl_tree_lrulock );
        /* LRU_ADD */
        if ( bdb->bi_idl_lru_head ) {
+               assert( bdb->bi_idl_lru_tail != NULL );
+               assert( bdb->bi_idl_lru_head->idl_lru_prev != NULL );
+               assert( bdb->bi_idl_lru_head->idl_lru_next != NULL );
+
                ee->idl_lru_next = bdb->bi_idl_lru_head;
                ee->idl_lru_prev = bdb->bi_idl_lru_head->idl_lru_prev;
                bdb->bi_idl_lru_head->idl_lru_prev->idl_lru_next = ee;
@@ -359,11 +374,14 @@ bdb_idl_cache_put(
        }
        bdb->bi_idl_lru_head = ee;
 
-       if ( ++bdb->bi_idl_cache_size > bdb->bi_idl_cache_max_size ) {
+       if ( bdb->bi_idl_cache_size >= bdb->bi_idl_cache_max_size ) {
                int i;
-               ee = bdb->bi_idl_lru_tail;
-               for ( i = 0; i < 10; i++, ee = eprev ) {
+               eprev = bdb->bi_idl_lru_tail;
+               for ( i = 0; (ee = eprev) != NULL && i < 10; i++ ) {
                        eprev = ee->idl_lru_prev;
+                       if ( eprev == ee ) {
+                               eprev = NULL;
+                       }
                        if ( ee->idl_flags & CACHE_ENTRY_REFERENCED ) {
                                ee->idl_flags ^= CACHE_ENTRY_REFERENCED;
                                continue;
@@ -382,7 +400,10 @@ bdb_idl_cache_put(
                        ch_free( ee );
                }
                bdb->bi_idl_lru_tail = eprev;
+               assert( bdb->bi_idl_lru_tail != NULL
+                       || bdb->bi_idl_lru_head == NULL );
        }
+       bdb->bi_idl_cache_size++;
        ldap_pvt_thread_mutex_unlock( &bdb->bi_idl_tree_lrulock );
        ldap_pvt_thread_rdwr_wunlock( &bdb->bi_idl_tree_rwlock );
 }
@@ -480,7 +501,7 @@ int
 bdb_idl_fetch_key(
        BackendDB       *be,
        DB                      *db,
-       DB_TXN          *tid,
+       DB_TXN          *txn,
        DBT                     *key,
        ID                      *ids,
        DBC                     **saved_cursor,
@@ -553,7 +574,7 @@ bdb_idl_fetch_key(
 
        /* If we're not reusing an existing cursor, get a new one */
        if( opflag != DB_NEXT ) {
-               rc = db->cursor( db, tid, &cursor, bdb->bi_db_opflags );
+               rc = db->cursor( db, txn, &cursor, bdb->bi_db_opflags );
                if( rc != 0 ) {
                        Debug( LDAP_DEBUG_ANY, "=> bdb_idl_fetch_key: "
                                "cursor failed: %s (%d)\n", db_strerror(rc), rc, 0 );
@@ -692,10 +713,6 @@ bdb_idl_insert_key(
 
        assert( id != NOID );
 
-       if ( bdb->bi_idl_cache_size ) {
-               bdb_idl_cache_del( bdb, db, key );
-       }
-
        DBTzero( &data );
        data.size = sizeof( ID );
        data.ulen = data.size;
@@ -868,6 +885,12 @@ fail:
                cursor->c_close( cursor );
                return rc;
        }
+       /* If key was added (didn't already exist) and using IDL cache,
+        * update key in IDL cache.
+        */
+       if ( !rc && bdb->bi_idl_cache_max_size ) {
+               bdb_idl_cache_add_id( bdb, db, key, id );
+       }
        rc = cursor->c_close( cursor );
        if( rc != 0 ) {
                Debug( LDAP_DEBUG_ANY, "=> bdb_idl_insert_key: "
@@ -900,7 +923,7 @@ bdb_idl_delete_key(
        }
        assert( id != NOID );
 
-       if ( bdb->bi_idl_cache_max_size ) {
+       if ( bdb->bi_idl_cache_size ) {
                bdb_idl_cache_del( bdb, db, key );
        }
 
@@ -1066,8 +1089,8 @@ bdb_idl_intersection(
         * turn it into a range.
         */
        if ( BDB_IDL_IS_RANGE( b )
-               && BDB_IDL_FIRST( b ) <= BDB_IDL_FIRST( a )
-               && BDB_IDL_LAST( b ) >= BDB_IDL_LAST( a ) ) {
+               && BDB_IDL_RANGE_FIRST( b ) <= BDB_IDL_RANGE_FIRST( a )
+               && BDB_IDL_RANGE_LAST( b ) >= BDB_IDL_RANGE_LAST( a ) ) {
                if (idmax - idmin + 1 == a[0])
                {
                        a[0] = NOID;
@@ -1286,11 +1309,11 @@ int bdb_idl_append_one( ID *ids, ID id )
 {
        if (BDB_IDL_IS_RANGE( ids )) {
                /* if already in range, treat as a dup */
-               if (id >= BDB_IDL_FIRST(ids) && id <= BDB_IDL_LAST(ids))
+               if (id >= BDB_IDL_RANGE_FIRST(ids) && id <= BDB_IDL_RANGE_LAST(ids))
                        return -1;
-               if (id < BDB_IDL_FIRST(ids))
+               if (id < BDB_IDL_RANGE_FIRST(ids))
                        ids[1] = id;
-               else if (id > BDB_IDL_LAST(ids))
+               else if (id > BDB_IDL_RANGE_LAST(ids))
                        ids[2] = id;
                return 0;
        }