Diff for /servers/slapd/overlays/syncprov.c between versions 1.147.2.56 and 1.275

version 1.147.2.56, 2009/03/17 16:36:59 version 1.275, 2009/03/13 07:33:34
Line 1 Line 1
 /* $OpenLDAP: pkg/ldap/servers/slapd/overlays/syncprov.c,v 1.147.2.55 2009/03/17 16:34:54 quanah Exp $ */  /* $OpenLDAP: pkg/ldap/servers/slapd/overlays/syncprov.c,v 1.274 2009/03/13 06:50:45 hyc Exp $ */
 /* syncprov.c - syncrepl provider */  /* syncprov.c - syncrepl provider */
 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.  /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
  *   *
Line 142  typedef struct syncprov_info_t { Line 142  typedef struct syncprov_info_t {
 typedef struct opcookie {  typedef struct opcookie {
         slap_overinst *son;          slap_overinst *son;
         syncmatches *smatches;          syncmatches *smatches;
         modtarget *smt;  
         struct berval sdn;      /* DN of entry, for deletes */          struct berval sdn;      /* DN of entry, for deletes */
         struct berval sndn;          struct berval sndn;
         struct berval suuid;    /* UUID of entry */          struct berval suuid;    /* UUID of entry */
Line 1314  syncprov_op_cleanup( Operation *op, Slap Line 1313  syncprov_op_cleanup( Operation *op, Slap
         }          }
   
         /* Remove op from lock table */          /* Remove op from lock table */
         mt = opc->smt;          mtdummy.mt_op = op;
           ldap_pvt_thread_mutex_lock( &si->si_mods_mutex );
           mt = avl_find( si->si_mods, &mtdummy, sp_avl_cmp );
         if ( mt ) {          if ( mt ) {
                 modinst *mi = mt->mt_mods;                  modinst *mi = mt->mt_mods;
   
                 /* If there are more, promote the next one */                  /* If there are more, promote the next one */
                   ldap_pvt_thread_mutex_lock( &mt->mt_mutex );
                 if ( mi->mi_next ) {                  if ( mi->mi_next ) {
                         ldap_pvt_thread_mutex_lock( &mt->mt_mutex );  
                         mt->mt_mods = mi->mi_next;                          mt->mt_mods = mi->mi_next;
                         mt->mt_op = mt->mt_mods->mi_op;                          mt->mt_op = mt->mt_mods->mi_op;
                         ldap_pvt_thread_mutex_unlock( &mt->mt_mutex );                          ldap_pvt_thread_mutex_unlock( &mt->mt_mutex );
                 } else {                  } else {
                         ldap_pvt_thread_mutex_lock( &si->si_mods_mutex );  
                         avl_delete( &si->si_mods, mt, sp_avl_cmp );                          avl_delete( &si->si_mods, mt, sp_avl_cmp );
                         ldap_pvt_thread_mutex_unlock( &si->si_mods_mutex );                          ldap_pvt_thread_mutex_unlock( &mt->mt_mutex );
                         ldap_pvt_thread_mutex_destroy( &mt->mt_mutex );                          ldap_pvt_thread_mutex_destroy( &mt->mt_mutex );
                         ch_free( mt );                          ch_free( mt );
                 }                  }
         }          }
           ldap_pvt_thread_mutex_unlock( &si->si_mods_mutex );
         if ( !BER_BVISNULL( &opc->suuid ))          if ( !BER_BVISNULL( &opc->suuid ))
                 op->o_tmpfree( opc->suuid.bv_val, op->o_tmpmemctx );                  op->o_tmpfree( opc->suuid.bv_val, op->o_tmpmemctx );
         if ( !BER_BVISNULL( &opc->sndn ))          if ( !BER_BVISNULL( &opc->sndn ))
Line 1644  syncprov_op_response( Operation *op, Sla Line 1645  syncprov_op_response( Operation *op, Sla
                 maxcsn.bv_len = sizeof(cbuf);                  maxcsn.bv_len = sizeof(cbuf);
                 ldap_pvt_thread_rdwr_wlock( &si->si_csn_rwlock );                  ldap_pvt_thread_rdwr_wlock( &si->si_csn_rwlock );
   
                 if ( op->o_dont_replicate && op->o_tag == LDAP_REQ_MODIFY &&  #if 0
                   if ( op->o_dont_replicate &&
                                 op->orm_modlist->sml_op == LDAP_MOD_REPLACE &&                                  op->orm_modlist->sml_op == LDAP_MOD_REPLACE &&
                                 op->orm_modlist->sml_desc == slap_schema.si_ad_contextCSN ) {                                  op->orm_modlist->sml_desc == slap_schema.si_ad_contextCSN ) {
                         /* Catch contextCSN updates from syncrepl. We have to look at                          /* Catch contextCSN updates from syncrepl. We have to look at
Line 1693  syncprov_op_response( Operation *op, Sla Line 1695  syncprov_op_response( Operation *op, Sla
                         }                          }
                         return SLAP_CB_CONTINUE;                          return SLAP_CB_CONTINUE;
                 }                  }
   #endif
   
                 slap_get_commit_csn( op, &maxcsn, &foundit );                  slap_get_commit_csn( op, &maxcsn, &foundit );
                 if ( BER_BVISEMPTY( &maxcsn ) && SLAP_GLUE_SUBORDINATE( op->o_bd )) {                  if ( BER_BVISEMPTY( &maxcsn ) && SLAP_GLUE_SUBORDINATE( op->o_bd )) {
Line 1733  syncprov_op_response( Operation *op, Sla Line 1736  syncprov_op_response( Operation *op, Sla
                                         sizeof(int));                                          sizeof(int));
                                 si->si_sids[i] = sid;                                  si->si_sids[i] = sid;
                         }                          }
 #if 0  
                 } else if ( !foundit ) {                  } else if ( !foundit ) {
                         /* internal ops that aren't meant to be replicated */                          /* internal ops that aren't meant to be replicated */
                         ldap_pvt_thread_rdwr_wunlock( &si->si_csn_rwlock );                          ldap_pvt_thread_rdwr_wunlock( &si->si_csn_rwlock );
                         return SLAP_CB_CONTINUE;                          return SLAP_CB_CONTINUE;
 #endif  
                 }                  }
   
                 /* Don't do any processing for consumer contextCSN updates */                  /* Don't do any processing for consumer contextCSN updates */
Line 1749  syncprov_op_response( Operation *op, Sla Line 1750  syncprov_op_response( Operation *op, Sla
   
                 si->si_numops++;                  si->si_numops++;
                 if ( si->si_chkops || si->si_chktime ) {                  if ( si->si_chkops || si->si_chktime ) {
                         /* Never checkpoint adding the context entry,                          if ( si->si_chkops && si->si_numops >= si->si_chkops ) {
                          * it will deadlock                                  do_check = 1;
                          */                                  si->si_numops = 0;
                         if ( op->o_tag != LDAP_REQ_ADD ||                          }
                                 !dn_match( &op->o_req_ndn, &op->o_bd->be_nsuffix[0] )) {                          if ( si->si_chktime &&
                                 if ( si->si_chkops && si->si_numops >= si->si_chkops ) {                                  (op->o_time - si->si_chklast >= si->si_chktime )) {
                                   if ( si->si_chklast ) {
                                         do_check = 1;                                          do_check = 1;
                                         si->si_numops = 0;                                          si->si_chklast = op->o_time;
                                 }                                  } else {
                                 if ( si->si_chktime &&                                          si->si_chklast = 1;
                                         (op->o_time - si->si_chklast >= si->si_chktime )) {  
                                         if ( si->si_chklast ) {  
                                                 do_check = 1;  
                                                 si->si_chklast = op->o_time;  
                                         } else {  
                                                 si->si_chklast = 1;  
                                         }  
                                 }                                  }
                         }                          }
                 }                  }
Line 1979  syncprov_op_mod( Operation *op, SlapRepl Line 1974  syncprov_op_mod( Operation *op, SlapRepl
                         avl_insert( &si->si_mods, mt, sp_avl_cmp, avl_dup_error );                          avl_insert( &si->si_mods, mt, sp_avl_cmp, avl_dup_error );
                         ldap_pvt_thread_mutex_unlock( &si->si_mods_mutex );                          ldap_pvt_thread_mutex_unlock( &si->si_mods_mutex );
                 }                  }
                 opc->smt = mt;  
         }          }
   
         if (( have_psearches || si->si_logs ) && op->o_tag != LDAP_REQ_ADD )          if (( have_psearches || si->si_logs ) && op->o_tag != LDAP_REQ_ADD )
Line 2383  syncprov_op_search( Operation *op, SlapR Line 2377  syncprov_op_search( Operation *op, SlapR
   
                 /* If nothing has changed, shortcut it */                  /* If nothing has changed, shortcut it */
                 if ( srs->sr_state.numcsns == numcsns ) {                  if ( srs->sr_state.numcsns == numcsns ) {
                         int i, j, newer;                          int i, j;
                         for ( i=0; i<srs->sr_state.numcsns; i++ ) {                          for ( i=0; i<srs->sr_state.numcsns; i++ ) {
                                 for ( j=0; j<numcsns; j++ ) {                                  for ( j=0; j<numcsns; j++ ) {
                                         if ( srs->sr_state.sids[i] != sids[j] )                                          if ( srs->sr_state.sids[i] != sids[j] )
                                                 continue;                                                  continue;
                                         newer = ber_bvcmp( &srs->sr_state.ctxcsn[i], &ctxcsn[j] );                                          if ( !bvmatch( &srs->sr_state.ctxcsn[i], &ctxcsn[j] ))
                                         /* If our state is newer, tell consumer about changes */  
                                         if ( newer < 0 )  
                                                 changed = SS_CHANGED;                                                  changed = SS_CHANGED;
                                         else if ( newer > 0 ) {  
                                         /* our state is older, tell consumer nothing */  
                                                 if ( sop ) {  
                                                         syncops **sp = &si->si_ops;  
                                                           
                                                         ldap_pvt_thread_mutex_lock( &si->si_ops_mutex );  
                                                         while ( *sp != sop )  
                                                                 sp = &(*sp)->s_next;  
                                                         *sp = sop->s_next;  
                                                         ldap_pvt_thread_mutex_unlock( &si->si_ops_mutex );  
                                                         ch_free( sop );  
                                                 }  
                                                 rs->sr_err = LDAP_SUCCESS;  
                                                 rs->sr_ctrls = NULL;  
                                                 send_ldap_result( op, rs );  
                                                 return rs->sr_err;  
                                         }  
                                         break;                                          break;
                                 }                                  }
                                 if ( changed )                                  if ( changed )

Removed from v.1.147.2.56  
changed lines
  Added in v.1.275


______________
© Copyright 1998-2020, OpenLDAP Foundation, info@OpenLDAP.org