Unify use of BDB lockers

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

diff --git a/servers/slapd/back-bdb/filterindex.c b/servers/slapd/back-bdb/filterindex.c
index 13bca595f77b093d424462a0da1652f2f1008ef4..07b269fb29dafd5abd5a9a99d03fb65d3d6c6f6f 100644 (file)
--- a/servers/slapd/back-bdb/filterindex.c
+++ b/servers/slapd/back-bdb/filterindex.c
@@ -2,7 +2,7 @@
 /* $OpenLDAP$ */
 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
  *
- * Copyright 2000-2006 The OpenLDAP Foundation.
+ * Copyright 2000-2007 The OpenLDAP Foundation.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -27,33 +27,39 @@
 
 static int presence_candidates(
        Operation *op,
+       u_int32_t locker,
        AttributeDescription *desc,
        ID *ids );
 
 static int equality_candidates(
        Operation *op,
+       u_int32_t locker,
        AttributeAssertion *ava,
        ID *ids,
        ID *tmp );
 static int inequality_candidates(
        Operation *op,
+       u_int32_t locker,
        AttributeAssertion *ava,
        ID *ids,
        ID *tmp,
        int gtorlt );
 static int approx_candidates(
        Operation *op,
+       u_int32_t locker,
        AttributeAssertion *ava,
        ID *ids,
        ID *tmp );
 static int substring_candidates(
        Operation *op,
+       u_int32_t locker,
        SubstringsAssertion *sub,
        ID *ids,
        ID *tmp );
 
 static int list_candidates(
        Operation *op,
+       u_int32_t locker,
        Filter *flist,
        int ftype,
        ID *ids,
@@ -64,6 +70,7 @@ static int list_candidates(
 static int
 ext_candidates(
         Operation *op,
+               u_int32_t locker,
         MatchingRuleAssertion *mra,
         ID *ids,
         ID *tmp,
@@ -72,6 +79,7 @@ ext_candidates(
 static int
 comp_candidates (
        Operation *op,
+       u_int32_t locker,
        MatchingRuleAssertion *mra,
        ComponentFilter *f,
        ID *ids,
@@ -81,6 +89,7 @@ comp_candidates (
 static int
 ava_comp_candidates (
                Operation *op,
+               u_int32_t locker,
                AttributeAssertion *ava,
                AttributeAliasing *aa,
                ID *ids,
@@ -91,6 +100,7 @@ ava_comp_candidates (
 int
 bdb_filter_candidates(
        Operation *op,
+       u_int32_t locker,
        Filter  *f,
        ID *ids,
        ID *tmp,
@@ -102,6 +112,11 @@ bdb_filter_candidates(
 #endif
        Debug( LDAP_DEBUG_FILTER, "=> bdb_filter_candidates\n", 0, 0, 0 );
 
+       if ( f->f_choice & SLAPD_FILTER_UNDEFINED ) {
+               BDB_IDL_ZERO( ids );
+               goto out;
+       }
+
        switch ( f->f_choice ) {
        case SLAPD_FILTER_COMPUTED:
                switch( f->f_result ) {
@@ -124,30 +139,30 @@ bdb_filter_candidates(
                break;
        case LDAP_FILTER_PRESENT:
                Debug( LDAP_DEBUG_FILTER, "\tPRESENT\n", 0, 0, 0 );
-               rc = presence_candidates( op, f->f_desc, ids );
+               rc = presence_candidates( op, locker, f->f_desc, ids );
                break;
 
        case LDAP_FILTER_EQUALITY:
                Debug( LDAP_DEBUG_FILTER, "\tEQUALITY\n", 0, 0, 0 );
 #ifdef LDAP_COMP_MATCH
                if ( is_aliased_attribute && ( aa = is_aliased_attribute ( f->f_ava->aa_desc ) ) ) {
-                       rc = ava_comp_candidates ( op, f->f_ava, aa, ids, tmp, stack );
+                       rc = ava_comp_candidates ( op, locker, f->f_ava, aa, ids, tmp, stack );
                }
                else
 #endif
                {
-                       rc = equality_candidates( op, f->f_ava, ids, tmp );
+                       rc = equality_candidates( op, locker, f->f_ava, ids, tmp );
                }
                break;
 
        case LDAP_FILTER_APPROX:
                Debug( LDAP_DEBUG_FILTER, "\tAPPROX\n", 0, 0, 0 );
-               rc = approx_candidates( op, f->f_ava, ids, tmp );
+               rc = approx_candidates( op, locker, f->f_ava, ids, tmp );
                break;
 
        case LDAP_FILTER_SUBSTRINGS:
                Debug( LDAP_DEBUG_FILTER, "\tSUBSTRINGS\n", 0, 0, 0 );
-               rc = substring_candidates( op, f->f_sub, ids, tmp );
+               rc = substring_candidates( op, locker, f->f_sub, ids, tmp );
                break;
 
        case LDAP_FILTER_GE:
@@ -155,9 +170,9 @@ bdb_filter_candidates(
                Debug( LDAP_DEBUG_FILTER, "\tGE\n", 0, 0, 0 );
                if( f->f_ava->aa_desc->ad_type->sat_ordering &&
                        ( f->f_ava->aa_desc->ad_type->sat_ordering->smr_usage & SLAP_MR_ORDERED_INDEX ) )
-                       rc = inequality_candidates( op, f->f_ava, ids, tmp, LDAP_FILTER_GE );
+                       rc = inequality_candidates( op, locker, f->f_ava, ids, tmp, LDAP_FILTER_GE );
                else
-                       rc = presence_candidates( op, f->f_ava->aa_desc, ids );
+                       rc = presence_candidates( op, locker, f->f_ava->aa_desc, ids );
                break;
 
        case LDAP_FILTER_LE:
@@ -165,9 +180,9 @@ bdb_filter_candidates(
                Debug( LDAP_DEBUG_FILTER, "\tLE\n", 0, 0, 0 );
                if( f->f_ava->aa_desc->ad_type->sat_ordering &&
                        ( f->f_ava->aa_desc->ad_type->sat_ordering->smr_usage & SLAP_MR_ORDERED_INDEX ) )
-                       rc = inequality_candidates( op, f->f_ava, ids, tmp, LDAP_FILTER_LE );
+                       rc = inequality_candidates( op, locker, f->f_ava, ids, tmp, LDAP_FILTER_LE );
                else
-                       rc = presence_candidates( op, f->f_ava->aa_desc, ids );
+                       rc = presence_candidates( op, locker, f->f_ava->aa_desc, ids );
                break;
 
        case LDAP_FILTER_NOT:
@@ -180,19 +195,19 @@ bdb_filter_candidates(
 
        case LDAP_FILTER_AND:
                Debug( LDAP_DEBUG_FILTER, "\tAND\n", 0, 0, 0 );
-               rc = list_candidates( op, 
+               rc = list_candidates( op, locker, 
                        f->f_and, LDAP_FILTER_AND, ids, tmp, stack );
                break;
 
        case LDAP_FILTER_OR:
                Debug( LDAP_DEBUG_FILTER, "\tOR\n", 0, 0, 0 );
-               rc = list_candidates( op, 
+               rc = list_candidates( op, locker,
                        f->f_or, LDAP_FILTER_OR, ids, tmp, stack );
                break;
 #ifdef LDAP_COMP_MATCH
        case LDAP_FILTER_EXT:
                 Debug( LDAP_DEBUG_FILTER, "\tEXT\n", 0, 0, 0 );
-                rc = ext_candidates( op, f->f_mra, ids, tmp, stack );
+                rc = ext_candidates( op, locker, f->f_mra, ids, tmp, stack );
                 break;
 #endif
        default:
@@ -204,6 +219,7 @@ bdb_filter_candidates(
                }
        }
 
+out:
        Debug( LDAP_DEBUG_FILTER,
                "<= bdb_filter_candidates: id=%ld first=%ld last=%ld\n",
                (long) ids[0],
@@ -217,6 +233,7 @@ bdb_filter_candidates(
 static int
 comp_list_candidates(
        Operation *op,
+       u_int32_t locker,
        MatchingRuleAssertion* mra,
        ComponentFilter *flist,
        int     ftype,
@@ -235,7 +252,7 @@ comp_list_candidates(
                        continue;
                }
                BDB_IDL_ZERO( save );
-               rc = comp_candidates( op, mra, f, save, tmp, save+BDB_IDL_UM_SIZE );
+               rc = comp_candidates( op, locker, mra, f, save, tmp, save+BDB_IDL_UM_SIZE );
 
                if ( rc != 0 ) {
                        if ( ftype == LDAP_COMP_FILTER_AND ) {
@@ -281,6 +298,7 @@ comp_list_candidates(
 static int
 comp_equality_candidates (
         Operation *op,
+       u_int32_t locker,
         MatchingRuleAssertion *mra,
        ComponentAssertion *ca,
         ID *ids,
@@ -357,7 +375,7 @@ comp_equality_candidates (
                 return 0;
         }
         for ( i= 0; keys[i].bv_val != NULL; i++ ) {
-                rc = bdb_key_read( op->o_bd, db, NULL, &keys[i], tmp, NULL, 0 );
+                rc = bdb_key_read( op->o_bd, db, locker, &keys[i], tmp, NULL, 0 );
 
                 if( rc == DB_NOTFOUND ) {
                         BDB_IDL_ZERO( ids );
@@ -394,6 +412,7 @@ comp_equality_candidates (
 static int
 ava_comp_candidates (
        Operation *op,
+       u_int32_t locker,
        AttributeAssertion *ava,
        AttributeAliasing *aa,
        ID *ids,
@@ -411,12 +430,13 @@ ava_comp_candidates (
        mra.ma_desc = aa->aa_aliased_ad;
        mra.ma_rule = ava->aa_desc->ad_type->sat_equality;
        
-       return comp_candidates ( op, &mra, ava->aa_cf, ids, tmp, stack );
+       return comp_candidates ( op, locker, &mra, ava->aa_cf, ids, tmp, stack );
 }
 
 static int
 comp_candidates (
        Operation *op,
+       u_int32_t locker,
        MatchingRuleAssertion *mra,
        ComponentFilter *f,
        ID *ids,
@@ -433,10 +453,10 @@ comp_candidates (
                rc = f->cf_result;
                break;
        case LDAP_COMP_FILTER_AND:
-               rc = comp_list_candidates( op, mra, f->cf_and, LDAP_COMP_FILTER_AND, ids, tmp, stack );
+               rc = comp_list_candidates( op, locker, mra, f->cf_and, LDAP_COMP_FILTER_AND, ids, tmp, stack );
                break;
        case LDAP_COMP_FILTER_OR:
-               rc = comp_list_candidates( op, mra, f->cf_or, LDAP_COMP_FILTER_OR, ids, tmp, stack );
+               rc = comp_list_candidates( op, locker, mra, f->cf_or, LDAP_COMP_FILTER_OR, ids, tmp, stack );
                break;
        case LDAP_COMP_FILTER_NOT:
                /* No component indexing supported for NOT filter */
@@ -448,7 +468,7 @@ comp_candidates (
                rc = LDAP_PROTOCOL_ERROR;
                break;
        case LDAP_COMP_FILTER_ITEM:
-               rc = comp_equality_candidates( op, mra, f->cf_ca, ids, tmp, stack );
+               rc = comp_equality_candidates( op, locker, mra, f->cf_ca, ids, tmp, stack );
                break;
        default:
                {
@@ -464,6 +484,7 @@ comp_candidates (
 static int
 ext_candidates(
         Operation *op,
+               u_int32_t locker,
         MatchingRuleAssertion *mra,
         ID *ids,
         ID *tmp,
@@ -479,13 +500,14 @@ ext_candidates(
                return 0;
        }
 
-       return comp_candidates ( op, mra, mra->ma_cf, ids, tmp, stack);
+       return comp_candidates ( op, locker, mra, mra->ma_cf, ids, tmp, stack);
 }
 #endif
 
 static int
 list_candidates(
        Operation *op,
+       u_int32_t locker,
        Filter  *flist,
        int             ftype,
        ID *ids,
@@ -503,7 +525,7 @@ list_candidates(
                        continue;
                }
                BDB_IDL_ZERO( save );
-               rc = bdb_filter_candidates( op, f, save, tmp,
+               rc = bdb_filter_candidates( op, locker, f, save, tmp,
                        save+BDB_IDL_UM_SIZE );
 
                if ( rc != 0 ) {
@@ -551,6 +573,7 @@ list_candidates(
 static int
 presence_candidates(
        Operation *op,
+       u_int32_t locker,
        AttributeDescription *desc,
        ID *ids )
 {
@@ -595,7 +618,7 @@ presence_candidates(
                return -1;
        }
 
-       rc = bdb_key_read( op->o_bd, db, NULL, &prefix, ids, NULL, 0 );
+       rc = bdb_key_read( op->o_bd, db, locker, &prefix, ids, NULL, 0 );
 
        if( rc == DB_NOTFOUND ) {
                BDB_IDL_ZERO( ids );
@@ -621,6 +644,7 @@ done:
 static int
 equality_candidates(
        Operation *op,
+       u_int32_t locker,
        AttributeAssertion *ava,
        ID *ids,
        ID *tmp )
@@ -691,7 +715,7 @@ equality_candidates(
        }
 
        for ( i= 0; keys[i].bv_val != NULL; i++ ) {
-               rc = bdb_key_read( op->o_bd, db, NULL, &keys[i], tmp, NULL, 0 );
+               rc = bdb_key_read( op->o_bd, db, locker, &keys[i], tmp, NULL, 0 );
 
                if( rc == DB_NOTFOUND ) {
                        BDB_IDL_ZERO( ids );
@@ -737,6 +761,7 @@ equality_candidates(
 static int
 approx_candidates(
        Operation *op,
+       u_int32_t locker,
        AttributeAssertion *ava,
        ID *ids,
        ID *tmp )
@@ -812,7 +837,7 @@ approx_candidates(
        }
 
        for ( i= 0; keys[i].bv_val != NULL; i++ ) {
-               rc = bdb_key_read( op->o_bd, db, NULL, &keys[i], tmp, NULL, 0 );
+               rc = bdb_key_read( op->o_bd, db, locker, &keys[i], tmp, NULL, 0 );
 
                if( rc == DB_NOTFOUND ) {
                        BDB_IDL_ZERO( ids );
@@ -856,6 +881,7 @@ approx_candidates(
 static int
 substring_candidates(
        Operation *op,
+       u_int32_t locker,
        SubstringsAssertion     *sub,
        ID *ids,
        ID *tmp )
@@ -927,7 +953,7 @@ substring_candidates(
        }
 
        for ( i= 0; keys[i].bv_val != NULL; i++ ) {
-               rc = bdb_key_read( op->o_bd, db, NULL, &keys[i], tmp, NULL, 0 );
+               rc = bdb_key_read( op->o_bd, db, locker, &keys[i], tmp, NULL, 0 );
 
                if( rc == DB_NOTFOUND ) {
                        BDB_IDL_ZERO( ids );
@@ -971,6 +997,7 @@ substring_candidates(
 static int
 inequality_candidates(
        Operation *op,
+       u_int32_t locker,
        AttributeAssertion *ava,
        ID *ids,
        ID *tmp,
@@ -1043,7 +1070,7 @@ inequality_candidates(
 
        BDB_IDL_ZERO( ids );
        while(1) {
-               rc = bdb_key_read( op->o_bd, db, NULL, &keys[0], tmp, &cursor, gtorlt );
+               rc = bdb_key_read( op->o_bd, db, locker, &keys[0], tmp, &cursor, gtorlt );
 
                if( rc == DB_NOTFOUND ) {
                        rc = 0;