Diff for /servers/slapd/overlays/syncprov.c between versions 1.176 and 1.183

version 1.176, 2007/02/06 03:19:56 version 1.183, 2007/02/14 07:51:47
Line 1 Line 1
 /* $OpenLDAP: pkg/ldap/servers/slapd/overlays/syncprov.c,v 1.175 2007/02/06 00:18:17 hyc Exp $ */  /* $OpenLDAP: pkg/ldap/servers/slapd/overlays/syncprov.c,v 1.182 2007/02/13 12:40:56 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 131  typedef struct syncprov_info_t { Line 131  typedef struct syncprov_info_t {
         time_t  si_chklast;     /* time of last checkpoint */          time_t  si_chklast;     /* time of last checkpoint */
         Avlnode *si_mods;       /* entries being modified */          Avlnode *si_mods;       /* entries being modified */
         sessionlog      *si_logs;          sessionlog      *si_logs;
         ldap_pvt_thread_mutex_t si_csn_mutex;          ldap_pvt_thread_rdwr_t  si_csn_rwlock;
         ldap_pvt_thread_mutex_t si_ops_mutex;          ldap_pvt_thread_mutex_t si_ops_mutex;
         ldap_pvt_thread_mutex_t si_mods_mutex;          ldap_pvt_thread_mutex_t si_mods_mutex;
 } syncprov_info_t;  } syncprov_info_t;
Line 904  syncprov_qtask( void *ctx, void *arg ) Line 904  syncprov_qtask( void *ctx, void *arg )
   
         *op->o_hdr = *so->s_op->o_hdr;          *op->o_hdr = *so->s_op->o_hdr;
   
         op->o_tmpmemctx = slap_sl_mem_create(SLAP_SLAB_SIZE, SLAP_SLAB_STACK, ctx);          op->o_tmpmemctx = slap_sl_mem_create(SLAP_SLAB_SIZE, SLAP_SLAB_STACK, ctx, 1);
         op->o_tmpmfuncs = &slap_sl_mfuncs;          op->o_tmpmfuncs = &slap_sl_mfuncs;
         op->o_threadctx = ctx;          op->o_threadctx = ctx;
   
Line 981  syncprov_qresp( opcookie *opc, syncops * Line 981  syncprov_qresp( opcookie *opc, syncops *
   
         /* Don't send changes back to their originator */          /* Don't send changes back to their originator */
         sid = slap_parse_csn_sid( &opc->sctxcsn );          sid = slap_parse_csn_sid( &opc->sctxcsn );
         if ( sid == so->s_sid )          if ( sid >= 0 && sid == so->s_sid )
                 return LDAP_SUCCESS;                  return LDAP_SUCCESS;
   
         sr = ch_malloc(sizeof(syncres) + opc->suuid.bv_len + 1 +          sr = ch_malloc(sizeof(syncres) + opc->suuid.bv_len + 1 +
Line 1552  syncprov_op_response( Operation *op, Sla Line 1552  syncprov_op_response( Operation *op, Sla
   
                 /* Update our context CSN */                  /* Update our context CSN */
                 cbuf[0] = '\0';                  cbuf[0] = '\0';
                 ldap_pvt_thread_mutex_lock( &si->si_csn_mutex );                  ldap_pvt_thread_rdwr_wlock( &si->si_csn_rwlock );
                 slap_get_commit_csn( op, &maxcsn );                  slap_get_commit_csn( op, &maxcsn );
                 if ( !BER_BVISNULL( &maxcsn ) ) {                  if ( !BER_BVISNULL( &maxcsn ) ) {
                         int i, sid;                          int i, sid;
Line 1579  syncprov_op_response( Operation *op, Sla Line 1579  syncprov_op_response( Operation *op, Sla
                 /* Don't do any processing for consumer contextCSN updates */                  /* Don't do any processing for consumer contextCSN updates */
                 if ( SLAP_SYNC_SHADOW( op->o_bd ) &&                   if ( SLAP_SYNC_SHADOW( op->o_bd ) && 
                         op->o_msgid == SLAP_SYNC_UPDATE_MSGID ) {                          op->o_msgid == SLAP_SYNC_UPDATE_MSGID ) {
                         ldap_pvt_thread_mutex_unlock( &si->si_csn_mutex );                          ldap_pvt_thread_rdwr_wunlock( &si->si_csn_rwlock );
                         return SLAP_CB_CONTINUE;                          return SLAP_CB_CONTINUE;
                 }                  }
   
Line 1595  syncprov_op_response( Operation *op, Sla Line 1595  syncprov_op_response( Operation *op, Sla
                                 si->si_chklast = op->o_time;                                  si->si_chklast = op->o_time;
                         }                          }
                 }                  }
                 ldap_pvt_thread_mutex_unlock( &si->si_csn_mutex );                  ldap_pvt_thread_rdwr_wunlock( &si->si_csn_rwlock );
   
                 opc->sctxcsn.bv_len = maxcsn.bv_len;  
                 opc->sctxcsn.bv_val = cbuf;  
   
                 if ( do_check ) {                  if ( do_check ) {
                           ldap_pvt_thread_rdwr_rlock( &si->si_csn_rwlock );
                         syncprov_checkpoint( op, rs, on );                          syncprov_checkpoint( op, rs, on );
                           ldap_pvt_thread_rdwr_runlock( &si->si_csn_rwlock );
                 }                  }
   
                   opc->sctxcsn.bv_len = maxcsn.bv_len;
                   opc->sctxcsn.bv_val = cbuf;
   
                 /* Handle any persistent searches */                  /* Handle any persistent searches */
                 if ( si->si_ops ) {                  if ( si->si_ops ) {
                         switch(op->o_tag) {                          switch(op->o_tag) {
Line 1658  syncprov_op_compare( Operation *op, Slap Line 1660  syncprov_op_compare( Operation *op, Slap
   
                 a.a_desc = slap_schema.si_ad_contextCSN;                  a.a_desc = slap_schema.si_ad_contextCSN;
   
                 ldap_pvt_thread_mutex_lock( &si->si_csn_mutex );                  ldap_pvt_thread_rdwr_rlock( &si->si_csn_rwlock );
   
                 a.a_vals = si->si_ctxcsn;                  a.a_vals = si->si_ctxcsn;
                 a.a_nvals = a.a_vals;                  a.a_nvals = a.a_vals;
Line 1690  syncprov_op_compare( Operation *op, Slap Line 1692  syncprov_op_compare( Operation *op, Slap
   
 return_results:;  return_results:;
   
                 ldap_pvt_thread_mutex_unlock( &si->si_csn_mutex );                  ldap_pvt_thread_rdwr_runlock( &si->si_csn_rwlock );
   
                 send_ldap_result( op, rs );                  send_ldap_result( op, rs );
   
Line 2073  syncprov_op_search( Operation *op, SlapR Line 2075  syncprov_op_search( Operation *op, SlapR
         }          }
   
         /* snapshot the ctxcsn */          /* snapshot the ctxcsn */
         ldap_pvt_thread_mutex_lock( &si->si_csn_mutex );          ldap_pvt_thread_rdwr_rlock( &si->si_csn_rwlock );
         numcsns = si->si_numcsns;          numcsns = si->si_numcsns;
         if ( numcsns ) {          if ( numcsns ) {
                 ber_bvarray_dup_x( &ctxcsn, si->si_ctxcsn, op->o_tmpmemctx );                  ber_bvarray_dup_x( &ctxcsn, si->si_ctxcsn, op->o_tmpmemctx );
Line 2084  syncprov_op_search( Operation *op, SlapR Line 2086  syncprov_op_search( Operation *op, SlapR
                 ctxcsn = NULL;                  ctxcsn = NULL;
                 sids = NULL;                  sids = NULL;
         }          }
         ldap_pvt_thread_mutex_unlock( &si->si_csn_mutex );          ldap_pvt_thread_rdwr_runlock( &si->si_csn_rwlock );
                   
         /* If we have a cookie, handle the PRESENT lookups */          /* If we have a cookie, handle the PRESENT lookups */
         if ( srs->sr_state.ctxcsn ) {          if ( srs->sr_state.ctxcsn ) {
Line 2177  no_change:  nochange = 1; Line 2179  no_change:  nochange = 1;
                         /* No, so a reload is required */                          /* No, so a reload is required */
                         /* the 2.2 consumer doesn't send this hint */                          /* the 2.2 consumer doesn't send this hint */
                         if ( si->si_usehint && srs->sr_rhint == 0 ) {                          if ( si->si_usehint && srs->sr_rhint == 0 ) {
                                   if ( ctxcsn )
                                           ber_bvarray_free_x( ctxcsn, op->o_tmpmemctx );
                                 send_ldap_error( op, rs, LDAP_SYNC_REFRESH_REQUIRED, "sync cookie is stale" );                                  send_ldap_error( op, rs, LDAP_SYNC_REFRESH_REQUIRED, "sync cookie is stale" );
                                 return rs->sr_err;                                  return rs->sr_err;
                         }                          }
Line 2185  no_change:  nochange = 1; Line 2189  no_change:  nochange = 1;
                         /* If changed and doing Present lookup, send Present UUIDs */                          /* If changed and doing Present lookup, send Present UUIDs */
                         if ( do_present && syncprov_findcsn( op, FIND_PRESENT ) !=                          if ( do_present && syncprov_findcsn( op, FIND_PRESENT ) !=
                                 LDAP_SUCCESS ) {                                  LDAP_SUCCESS ) {
                                   if ( ctxcsn )
                                           ber_bvarray_free_x( ctxcsn, op->o_tmpmemctx );
                                 send_ldap_result( op, rs );                                  send_ldap_result( op, rs );
                                 return rs->sr_err;                                  return rs->sr_err;
                         }                          }
Line 2270  syncprov_operational( Line 2276  syncprov_operational(
                                         break;                                          break;
                         }                          }
   
                         ldap_pvt_thread_mutex_lock( &si->si_csn_mutex );                          ldap_pvt_thread_rdwr_rlock( &si->si_csn_rwlock );
                         if ( si->si_ctxcsn ) {                          if ( si->si_ctxcsn ) {
                                 if ( !a ) {                                  if ( !a ) {
                                         for ( ap = &rs->sr_operational_attrs; *ap;                                          for ( ap = &rs->sr_operational_attrs; *ap;
Line 2293  syncprov_operational( Line 2299  syncprov_operational(
                                 ber_bvarray_dup_x( &a->a_vals, si->si_ctxcsn, NULL );                                  ber_bvarray_dup_x( &a->a_vals, si->si_ctxcsn, NULL );
                                 a->a_nvals = a->a_vals;                                  a->a_nvals = a->a_vals;
                         }                          }
                         ldap_pvt_thread_mutex_unlock( &si->si_csn_mutex );                          ldap_pvt_thread_rdwr_runlock( &si->si_csn_rwlock );
                 }                  }
         }          }
         return SLAP_CB_CONTINUE;          return SLAP_CB_CONTINUE;
Line 2537  syncprov_db_open( Line 2543  syncprov_db_open(
                 if ( a ) {                  if ( a ) {
                         int i;                          int i;
                         ber_bvarray_dup_x( &si->si_ctxcsn, a->a_vals, NULL );                          ber_bvarray_dup_x( &si->si_ctxcsn, a->a_vals, NULL );
                         for ( i=0; !BER_BVISEMPTY( &a->a_vals[i] ); i++ );                          for ( i = 0; !BER_BVISNULL( &a->a_vals[i] ); i++ );
                         si->si_numcsns = i;                          si->si_numcsns = i;
                         si->si_sids = slap_parse_csn_sids( si->si_ctxcsn, i );                          si->si_sids = slap_parse_csn_sids( si->si_ctxcsn, i );
                 }                  }
Line 2628  syncprov_db_init( Line 2634  syncprov_db_init(
   
         si = ch_calloc(1, sizeof(syncprov_info_t));          si = ch_calloc(1, sizeof(syncprov_info_t));
         on->on_bi.bi_private = si;          on->on_bi.bi_private = si;
         ldap_pvt_thread_mutex_init( &si->si_csn_mutex );          ldap_pvt_thread_rdwr_init( &si->si_csn_rwlock );
         ldap_pvt_thread_mutex_init( &si->si_ops_mutex );          ldap_pvt_thread_mutex_init( &si->si_ops_mutex );
         ldap_pvt_thread_mutex_init( &si->si_mods_mutex );          ldap_pvt_thread_mutex_init( &si->si_mods_mutex );
   
Line 2663  syncprov_db_destroy( Line 2669  syncprov_db_destroy(
                                                                   
                         ch_free( si->si_logs );                          ch_free( si->si_logs );
                 }                  }
                   if ( si->si_ctxcsn )
                           ber_bvarray_free( si->si_ctxcsn );
                   if ( si->si_sids )
                           ch_free( si->si_sids );
                 ldap_pvt_thread_mutex_destroy( &si->si_mods_mutex );                  ldap_pvt_thread_mutex_destroy( &si->si_mods_mutex );
                 ldap_pvt_thread_mutex_destroy( &si->si_ops_mutex );                  ldap_pvt_thread_mutex_destroy( &si->si_ops_mutex );
                 ldap_pvt_thread_mutex_destroy( &si->si_csn_mutex );                  ldap_pvt_thread_rdwr_destroy( &si->si_csn_rwlock );
                 ch_free( si );                  ch_free( si );
         }          }
   

Removed from v.1.176  
changed lines
  Added in v.1.183


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