git.sur5r.net Git - openldap/blob - servers/slapd/back-bdb/add.c

   1 /* add.c - ldap BerkeleyDB back-end add routine */
   2 /* $OpenLDAP$ */
   3 /*
   4  * Copyright 1998-2003 The OpenLDAP Foundation, All Rights Reserved.
   5  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   6  */
   7
   8 #include "portable.h"
   9
  10 #include <stdio.h>
  11 #include <ac/string.h>
  12
  13 #include "back-bdb.h"
  14 #include "external.h"
  15
  16 int
  17 bdb_add(Operation *op, SlapReply *rs )
  18 {
  19         struct bdb_info *bdb = (struct bdb_info *) op->o_bd->be_private;
  20         struct berval   pdn;
  21         Entry           *p;
  22         EntryInfo       *ei;
  23         char textbuf[SLAP_TEXT_BUFLEN];
  24         size_t textlen = sizeof textbuf;
  25         AttributeDescription *children = slap_schema.si_ad_children;
  26         AttributeDescription *entry = slap_schema.si_ad_entry;
  27         DB_TXN          *ltid = NULL, *lt2;
  28         struct bdb_op_info opinfo;
  29 #ifdef BDB_SUBENTRIES
  30         int subentry;
  31 #endif
  32         u_int32_t       locker = 0;
  33         DB_LOCK         lock;
  34         int             noop = 0;
  35
  36         int             num_retries = 0;
  37
  38         Operation* ps_list;
  39         int             rc;
  40         EntryInfo       *suffix_ei = NULL;
  41         Entry           *ctxcsn_e;
  42         int                     ctxcsn_added = 0;
  43
  44         LDAPControl *ctrls[SLAP_MAX_RESPONSE_CONTROLS];
  45         int num_ctrls = 0;
  46
  47 #ifdef NEW_LOGGING
  48         LDAP_LOG ( OPERATION, ARGS, "==> bdb_add: %s\n", op->oq_add.rs_e->e_name.bv_val, 0, 0 );
  49 #else
  50         Debug(LDAP_DEBUG_ARGS, "==> bdb_add: %s\n", op->oq_add.rs_e->e_name.bv_val, 0, 0);
  51 #endif
  52
  53         /* check entry's schema */
  54         rs->sr_err = entry_schema_check( op->o_bd, op->oq_add.rs_e, NULL, &rs->sr_text, textbuf, textlen );
  55         if ( rs->sr_err != LDAP_SUCCESS ) {
  56 #ifdef NEW_LOGGING
  57         LDAP_LOG ( OPERATION, ERR,
  58                 "bdb_add: entry failed schema check: %s (%d)\n", rs->sr_text, rs->sr_err, 0 );
  59 #else
  60                 Debug( LDAP_DEBUG_TRACE,
  61                         "bdb_add: entry failed schema check: %s (%d)\n",
  62                         rs->sr_text, rs->sr_err, 0 );
  63 #endif
  64                 goto return_results;
  65         }
  66
  67 #ifdef BDB_SUBENTRIES
  68         subentry = is_entry_subentry( op->oq_add.rs_e );
  69 #endif
  70
  71         /*
  72          * acquire an ID outside of the operation transaction
  73          * to avoid serializing adds.
  74          */
  75         rs->sr_err = bdb_next_id( op->o_bd, NULL, &op->oq_add.rs_e->e_id );
  76         if( rs->sr_err != 0 ) {
  77 #ifdef NEW_LOGGING
  78                 LDAP_LOG ( OPERATION, ERR,
  79                         "bdb_add: next_id failed (%d)\n", rs->sr_err, 0, 0 );
  80 #else
  81                 Debug( LDAP_DEBUG_TRACE,
  82                         "bdb_add: next_id failed (%d)\n", rs->sr_err, 0, 0 );
  83 #endif
  84                 rs->sr_err = LDAP_OTHER;
  85                 rs->sr_text = "internal error";
  86                 goto return_results;
  87         }
  88
  89         if( 0 ) {
  90 retry:  /* transaction retry */
  91                 if( p ) {
  92                         /* free parent and reader lock */
  93                         bdb_unlocked_cache_return_entry_r( &bdb->bi_cache, p );
  94                         p = NULL;
  95                 }
  96                 rs->sr_err = TXN_ABORT( ltid );
  97                 ltid = NULL;
  98                 op->o_private = NULL;
  99                 op->o_do_not_cache = opinfo.boi_acl_cache;
 100                 if( rs->sr_err != 0 ) {
 101                         rs->sr_err = LDAP_OTHER;
 102                         rs->sr_text = "internal error";
 103                         goto return_results;
 104                 }
 105                 ldap_pvt_thread_yield();
 106                 bdb_trans_backoff( ++num_retries );
 107         }
 108
 109         /* begin transaction */
 110         rs->sr_err = TXN_BEGIN( bdb->bi_dbenv, NULL, &ltid,
 111                 bdb->bi_db_opflags );
 112         rs->sr_text = NULL;
 113         if( rs->sr_err != 0 ) {
 114 #ifdef NEW_LOGGING
 115                 LDAP_LOG ( OPERATION, ERR,
 116                         "bdb_add: txn_begin failed: %s (%d)\n", db_strerror(rs->sr_err), rs->sr_err, 0 );
 117 #else
 118                 Debug( LDAP_DEBUG_TRACE,
 119                         "bdb_add: txn_begin failed: %s (%d)\n",
 120                         db_strerror(rs->sr_err), rs->sr_err, 0 );
 121 #endif
 122                 rs->sr_err = LDAP_OTHER;
 123                 rs->sr_text = "internal error";
 124                 goto return_results;
 125         }
 126
 127         locker = TXN_ID ( ltid );
 128
 129         opinfo.boi_bdb = op->o_bd;
 130         opinfo.boi_txn = ltid;
 131         opinfo.boi_locker = locker;
 132         opinfo.boi_err = 0;
 133         opinfo.boi_acl_cache = op->o_do_not_cache;
 134         op->o_private = &opinfo;
 135
 136         /*
 137          * Get the parent dn and see if the corresponding entry exists.
 138          * If the parent does not exist, only allow the "root" user to
 139          * add the entry.
 140          */
 141         if ( be_issuffix( op->o_bd, &op->oq_add.rs_e->e_nname ) ) {
 142                 pdn = slap_empty_bv;
 143         } else {
 144                 dnParent( &op->oq_add.rs_e->e_nname, &pdn );
 145         }
 146
 147         /* get entry or parent */
 148         rs->sr_err = bdb_dn2entry( op, ltid, &op->ora_e->e_nname, &ei,
 149                 1, locker, &lock );
 150         switch( rs->sr_err ) {
 151         case 0:
 152                 rs->sr_err = LDAP_ALREADY_EXISTS;
 153                 goto return_results;
 154         case DB_NOTFOUND:
 155                 break;
 156         case DB_LOCK_DEADLOCK:
 157         case DB_LOCK_NOTGRANTED:
 158                 goto retry;
 159         case LDAP_BUSY:
 160                 rs->sr_text = "ldap server busy";
 161                 goto return_results;
 162         default:
 163                 rs->sr_err = LDAP_OTHER;
 164                 rs->sr_text = "internal error";
 165                 goto return_results;
 166         }
 167
 168         p = ei->bei_e;
 169         if ( p ) {
 170                 if ( !bvmatch( &pdn, &p->e_nname ) ) {
 171                         rs->sr_matched = ber_strdup_x( p->e_name.bv_val,
 172                                 op->o_tmpmemctx );
 173                         rs->sr_ref = is_entry_referral( p )
 174                                 ? get_entry_referrals( op, p )
 175                                 : NULL;
 176                         bdb_unlocked_cache_return_entry_r( &bdb->bi_cache, p );
 177                         p = NULL;
 178 #ifdef NEW_LOGGING
 179                         LDAP_LOG ( OPERATION, DETAIL1,
 180                                 "bdb_add: parent does not exist\n", 0, 0, 0 );
 181 #else
 182                         Debug( LDAP_DEBUG_TRACE, "bdb_add: parent does not exist\n",
 183                                 0, 0, 0 );
 184 #endif
 185
 186                         rs->sr_err = LDAP_REFERRAL;
 187                         send_ldap_result( op, rs );
 188
 189                         ber_bvarray_free( rs->sr_ref );
 190                         op->o_tmpfree( (char *)rs->sr_matched, op->o_tmpmemctx );
 191                         rs->sr_ref = NULL;
 192                         rs->sr_matched = NULL;
 193
 194                         goto done;
 195                 }
 196
 197                 rs->sr_err = access_allowed( op, p,
 198                         children, NULL, ACL_WRITE, NULL );
 199
 200                 if ( ! rs->sr_err ) {
 201                         switch( opinfo.boi_err ) {
 202                         case DB_LOCK_DEADLOCK:
 203                         case DB_LOCK_NOTGRANTED:
 204                                 goto retry;
 205                         }
 206
 207 #ifdef NEW_LOGGING
 208                         LDAP_LOG ( OPERATION, DETAIL1,
 209                                 "bdb_add: no write access to parent\n", 0, 0, 0 );
 210 #else
 211                         Debug( LDAP_DEBUG_TRACE, "bdb_add: no write access to parent\n",
 212                                 0, 0, 0 );
 213 #endif
 214                         rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
 215                         rs->sr_text = "no write access to parent";
 216                         goto return_results;;
 217                 }
 218
 219 #ifdef BDB_SUBENTRIES
 220                 if ( is_entry_subentry( p ) ) {
 221                         /* parent is a subentry, don't allow add */
 222 #ifdef NEW_LOGGING
 223                         LDAP_LOG ( OPERATION, DETAIL1,
 224                                 "bdb_add: parent is subentry\n", 0, 0, 0 );
 225 #else
 226                         Debug( LDAP_DEBUG_TRACE, "bdb_add: parent is subentry\n",
 227                                 0, 0, 0 );
 228 #endif
 229                         rs->sr_err = LDAP_OBJECT_CLASS_VIOLATION;
 230                         rs->sr_text = "parent is a subentry";
 231                         goto return_results;;
 232                 }
 233 #endif
 234 #ifdef BDB_ALIASES
 235                 if ( is_entry_alias( p ) ) {
 236                         /* parent is an alias, don't allow add */
 237 #ifdef NEW_LOGGING
 238                         LDAP_LOG ( OPERATION, DETAIL1,
 239                                 "bdb_add: parent is alias\n", 0, 0, 0 );
 240 #else
 241                         Debug( LDAP_DEBUG_TRACE, "bdb_add: parent is alias\n",
 242                                 0, 0, 0 );
 243 #endif
 244                         rs->sr_err = LDAP_ALIAS_PROBLEM;
 245                         rs->sr_text = "parent is an alias";
 246                         goto return_results;;
 247                 }
 248 #endif
 249
 250                 if ( is_entry_referral( p ) ) {
 251                         /* parent is a referral, don't allow add */
 252                         rs->sr_matched = p->e_name.bv_val;
 253                         rs->sr_ref = get_entry_referrals( op, p );
 254
 255 #ifdef NEW_LOGGING
 256                         LDAP_LOG ( OPERATION, DETAIL1,
 257                                 "bdb_add: parent is referral\n", 0, 0, 0 );
 258 #else
 259                         Debug( LDAP_DEBUG_TRACE, "bdb_add: parent is referral\n",
 260                                 0, 0, 0 );
 261 #endif
 262
 263                         rs->sr_err = LDAP_REFERRAL;
 264                         send_ldap_result( op, rs );
 265
 266                         ber_bvarray_free( rs->sr_ref );
 267                         bdb_unlocked_cache_return_entry_r( &bdb->bi_cache, p );
 268                         rs->sr_ref = NULL;
 269                         rs->sr_matched = NULL;
 270                         p = NULL;
 271                         goto done;
 272                 }
 273
 274 #ifdef BDB_SUBENTRIES
 275                 if ( subentry ) {
 276                         /* FIXME: */
 277                         /* parent must be an administrative point of the required kind */
 278                 }
 279 #endif
 280
 281                 /* free parent and reader lock */
 282                 bdb_unlocked_cache_return_entry_r( &bdb->bi_cache, p );
 283                 p = NULL;
 284
 285         } else {
 286                 /*
 287                  * no parent!
 288                  *      must be adding entry at suffix or with parent ""
 289                  */
 290                 if ( be_issuffix( op->o_bd, (struct berval *)&slap_empty_bv )
 291                         || be_isupdate( op->o_bd, &op->o_ndn ) )
 292                 {
 293                         p = (Entry *)&slap_entry_root;
 294
 295                         /* check parent for "children" acl */
 296                         rs->sr_err = access_allowed( op, p,
 297                                 children, NULL, ACL_WRITE, NULL );
 298
 299                         p = NULL;
 300
 301                         if ( ! rs->sr_err ) {
 302                                 switch( opinfo.boi_err ) {
 303                                 case DB_LOCK_DEADLOCK:
 304                                 case DB_LOCK_NOTGRANTED:
 305                                         goto retry;
 306                                 }
 307
 308 #ifdef NEW_LOGGING
 309                                 LDAP_LOG ( OPERATION, DETAIL1,
 310                                         "bdb_add: no write access to parent\n", 0, 0, 0 );
 311 #else
 312                                 Debug( LDAP_DEBUG_TRACE,
 313                                         "bdb_add: no write access to parent\n",
 314                                         0, 0, 0 );
 315 #endif
 316                                 rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
 317                                 rs->sr_text = "no write access to parent";
 318                                 goto return_results;
 319                         }
 320
 321                 } else if ( !is_entry_glue( op->oq_add.rs_e )) {
 322 #ifdef NEW_LOGGING
 323                         LDAP_LOG ( OPERATION, DETAIL1, "bdb_add: %s denied\n",
 324                                 pdn.bv_len == 0 ? "suffix" : "entry at root", 0, 0 );
 325 #else
 326                         Debug( LDAP_DEBUG_TRACE, "bdb_add: %s denied\n",
 327                                 pdn.bv_len == 0 ? "suffix" : "entry at root",
 328                                 0, 0 );
 329 #endif
 330                         rs->sr_err = LDAP_NO_SUCH_OBJECT;
 331                         goto return_results;
 332                 }
 333         }
 334
 335         if ( get_assert( op ) &&
 336                 ( test_filter( op, op->oq_add.rs_e, get_assertion( op ))
 337                         != LDAP_COMPARE_TRUE ))
 338         {
 339                 rs->sr_err = LDAP_ASSERTION_FAILED;
 340                 goto return_results;
 341         }
 342
 343         rs->sr_err = access_allowed( op, op->oq_add.rs_e,
 344                 entry, NULL, ACL_WRITE, NULL );
 345
 346         if ( ! rs->sr_err ) {
 347                 switch( opinfo.boi_err ) {
 348                 case DB_LOCK_DEADLOCK:
 349                 case DB_LOCK_NOTGRANTED:
 350                         goto retry;
 351                 }
 352
 353 #ifdef NEW_LOGGING
 354                 LDAP_LOG ( OPERATION, DETAIL1,
 355                         "bdb_add: no write access to entry\n", 0, 0, 0 );
 356 #else
 357                 Debug( LDAP_DEBUG_TRACE, "bdb_add: no write access to entry\n",
 358                         0, 0, 0 );
 359 #endif
 360                 rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
 361                 rs->sr_text = "no write access to entry";
 362                 goto return_results;;
 363         }
 364
 365         /* post-read */
 366         if( op->o_postread ) {
 367                 if ( slap_read_controls( op, rs, op->oq_add.rs_e,
 368                         &slap_post_read_bv, &ctrls[num_ctrls] ) )
 369                 {
 370 #ifdef NEW_LOGGING
 371                         LDAP_LOG ( OPERATION, DETAIL1,
 372                                 "<=- bdb_add: post-read failed!\n", 0, 0, 0 );
 373 #else
 374                         Debug( LDAP_DEBUG_TRACE,
 375                                 "<=- bdb_add: post-read failed!\n", 0, 0, 0 );
 376 #endif
 377                         goto return_results;
 378                 }
 379                 ctrls[++num_ctrls] = NULL;
 380         }
 381
 382         /* nested transaction */
 383         rs->sr_err = TXN_BEGIN( bdb->bi_dbenv, ltid, &lt2,
 384                 bdb->bi_db_opflags );
 385         rs->sr_text = NULL;
 386         if( rs->sr_err != 0 ) {
 387 #ifdef NEW_LOGGING
 388                 LDAP_LOG ( OPERATION, ERR,
 389                         "bdb_add: txn_begin(2) failed: %s (%d)\n", db_strerror(rs->sr_err), rs->sr_err, 0 );
 390 #else
 391                 Debug( LDAP_DEBUG_TRACE,
 392                         "bdb_add: txn_begin(2) failed: %s (%d)\n",
 393                         db_strerror(rs->sr_err), rs->sr_err, 0 );
 394 #endif
 395                 rs->sr_err = LDAP_OTHER;
 396                 rs->sr_text = "internal error";
 397                 goto return_results;
 398         }
 399
 400         /* dn2id index */
 401         rs->sr_err = bdb_dn2id_add( op, lt2, ei, op->oq_add.rs_e );
 402         if ( rs->sr_err != 0 ) {
 403 #ifdef NEW_LOGGING
 404                 LDAP_LOG ( OPERATION, ERR,
 405                         "bdb_add: dn2id_add failed: %s (%d)\n", db_strerror(rs->sr_err), rs->sr_err, 0 );
 406 #else
 407                 Debug( LDAP_DEBUG_TRACE, "bdb_add: dn2id_add failed: %s (%d)\n",
 408                         db_strerror(rs->sr_err), rs->sr_err, 0 );
 409 #endif
 410
 411                 switch( rs->sr_err ) {
 412                 case DB_LOCK_DEADLOCK:
 413                 case DB_LOCK_NOTGRANTED:
 414                         goto retry;
 415                 case DB_KEYEXIST:
 416                         rs->sr_err = LDAP_ALREADY_EXISTS;
 417                         break;
 418                 default:
 419                         rs->sr_err = LDAP_OTHER;
 420                 }
 421                 goto return_results;
 422         }
 423
 424         /* id2entry index */
 425         rs->sr_err = bdb_id2entry_add( op->o_bd, lt2, op->oq_add.rs_e );
 426         if ( rs->sr_err != 0 ) {
 427 #ifdef NEW_LOGGING
 428                 LDAP_LOG ( OPERATION, ERR, "bdb_add: id2entry_add failed\n", 0, 0, 0 );
 429 #else
 430                 Debug( LDAP_DEBUG_TRACE, "bdb_add: id2entry_add failed\n",
 431                         0, 0, 0 );
 432 #endif
 433                 switch( rs->sr_err ) {
 434                 case DB_LOCK_DEADLOCK:
 435                 case DB_LOCK_NOTGRANTED:
 436                         goto retry;
 437                 default:
 438                         rs->sr_err = LDAP_OTHER;
 439                 }
 440                 rs->sr_text = "entry store failed";
 441                 goto return_results;
 442         }
 443
 444         /* attribute indexes */
 445         rs->sr_err = bdb_index_entry_add( op, lt2, op->oq_add.rs_e );
 446         if ( rs->sr_err != LDAP_SUCCESS ) {
 447 #ifdef NEW_LOGGING
 448                 LDAP_LOG ( OPERATION, ERR,
 449                         "bdb_add: index_entry_add failed\n", 0, 0, 0 );
 450 #else
 451                 Debug( LDAP_DEBUG_TRACE, "bdb_add: index_entry_add failed\n",
 452                         0, 0, 0 );
 453 #endif
 454                 switch( rs->sr_err ) {
 455                 case DB_LOCK_DEADLOCK:
 456                 case DB_LOCK_NOTGRANTED:
 457                         goto retry;
 458                 default:
 459                         rs->sr_err = LDAP_OTHER;
 460                 }
 461                 rs->sr_text = "index generation failed";
 462                 goto return_results;
 463         }
 464         if ( TXN_COMMIT( lt2, 0 ) != 0 ) {
 465                 rs->sr_err = LDAP_OTHER;
 466                 rs->sr_text = "txn_commit(2) failed";
 467                 goto return_results;
 468         }
 469
 470         if ( !op->o_bd->syncinfo ) {
 471                 rc = bdb_csn_commit( op, rs, ltid, ei, &suffix_ei,
 472                         &ctxcsn_e, &ctxcsn_added, locker );
 473                 switch ( rc ) {
 474                 case BDB_CSN_ABORT :
 475                         goto return_results;
 476                 case BDB_CSN_RETRY :
 477                         goto retry;
 478                 }
 479         }
 480
 481         if ( op->o_noop ) {
 482                 if (( rs->sr_err=TXN_ABORT( ltid )) != 0 ) {
 483                         rs->sr_text = "txn_abort (no-op) failed";
 484                 } else {
 485                         noop = 1;
 486                         rs->sr_err = LDAP_SUCCESS;
 487                 }
 488
 489         } else {
 490                 char gid[DB_XIDDATASIZE];
 491
 492                 memset( gid, 0, sizeof(gid) );
 493                 snprintf( gid, sizeof( gid ), "%s-%08lx-%08lx",
 494                         bdb_uuid.bv_val, (long) op->o_connid, (long) op->o_opid );
 495
 496                 if (( rs->sr_err=TXN_PREPARE( ltid, gid )) != 0 ) {
 497                         rs->sr_text = "txn_prepare failed";
 498
 499                 } else {
 500                         struct berval nrdn;
 501
 502                         if (pdn.bv_len) {
 503                                 nrdn.bv_val = op->ora_e->e_nname.bv_val;
 504                                 nrdn.bv_len = pdn.bv_val - nrdn.bv_val - 1;
 505                         } else {
 506                                 nrdn = op->ora_e->e_nname;
 507                         }
 508
 509                         bdb_cache_add( bdb, ei, op->oq_add.rs_e, &nrdn, locker );
 510
 511                         if ( suffix_ei == NULL ) {
 512                                 suffix_ei = op->oq_add.rs_e->e_private;
 513                         }
 514
 515                         if ( !op->o_bd->syncinfo ) {
 516                                 if ( ctxcsn_added ) {
 517                                         bdb_cache_add( bdb, suffix_ei, ctxcsn_e, (struct berval *)&slap_ldapsync_cn_bv, locker );
 518                                 }
 519                         }
 520
 521                         if(( rs->sr_err=TXN_COMMIT( ltid, 0 )) != 0 ) {
 522                                 rs->sr_text = "txn_commit failed";
 523                         } else {
 524                                 rs->sr_err = LDAP_SUCCESS;
 525                         }
 526                 }
 527         }
 528
 529         ltid = NULL;
 530         op->o_private = NULL;
 531
 532         if (rs->sr_err != LDAP_SUCCESS) {
 533 #ifdef NEW_LOGGING
 534                 LDAP_LOG ( OPERATION, ERR,
 535                         "bdb_add: %s : %s (%d)\n",  rs->sr_text,
 536                                 db_strerror(rs->sr_err), rs->sr_err );
 537 #else
 538                 Debug( LDAP_DEBUG_TRACE, "bdb_add: %s : %s (%d)\n",
 539                         rs->sr_text, db_strerror(rs->sr_err), rs->sr_err );
 540 #endif
 541                 rs->sr_err = LDAP_OTHER;
 542                 goto return_results;
 543         }
 544
 545 #ifdef NEW_LOGGING
 546         LDAP_LOG ( OPERATION, RESULTS,
 547                 "bdb_add: added%s id=%08lx dn=\"%s\"\n",
 548                 op->o_noop ? " (no-op)" : "",
 549                 op->oq_add.rs_e->e_id, op->oq_add.rs_e->e_dn );
 550 #else
 551         Debug(LDAP_DEBUG_TRACE, "bdb_add: added%s id=%08lx dn=\"%s\"\n",
 552                 op->o_noop ? " (no-op)" : "",
 553                 op->oq_add.rs_e->e_id, op->oq_add.rs_e->e_dn );
 554 #endif
 555
 556         rs->sr_text = NULL;
 557         if( num_ctrls ) rs->sr_ctrls = ctrls;
 558
 559 return_results:
 560         send_ldap_result( op, rs );
 561
 562         if ( rs->sr_err == LDAP_SUCCESS && !noop ) {
 563                 LDAP_LIST_FOREACH ( ps_list, &bdb->bi_psearch_list, o_ps_link ) {
 564                         bdb_psearch( op, rs, ps_list, op->oq_add.rs_e, LDAP_PSEARCH_BY_ADD );
 565                 }
 566         }
 567
 568         if( rs->sr_err == LDAP_SUCCESS && bdb->bi_txn_cp ) {
 569                 ldap_pvt_thread_yield();
 570                 TXN_CHECKPOINT( bdb->bi_dbenv,
 571                         bdb->bi_txn_cp_kbyte, bdb->bi_txn_cp_min, 0 );
 572         }
 573
 574 done:
 575         if( ltid != NULL ) {
 576                 TXN_ABORT( ltid );
 577                 op->o_private = NULL;
 578         }
 579
 580         return ( ( rs->sr_err == LDAP_SUCCESS ) ? noop : rs->sr_err );
 581 }