Diff for /servers/slapd/overlays/syncprov.c between versions 1.147.2.60 and 1.281

version 1.147.2.60, 2009/10/31 00:14:39 version 1.281, 2009/03/14 08:03:30
Line 1 Line 1
 /* $OpenLDAP$ */  /* $OpenLDAP: pkg/ldap/servers/slapd/overlays/syncprov.c,v 1.280 2009/03/14 06:22:19 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 137  typedef struct syncprov_info_t { Line 137  typedef struct syncprov_info_t {
         ldap_pvt_thread_rdwr_t  si_csn_rwlock;          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;
         ldap_pvt_thread_mutex_t si_resp_mutex;  
 } syncprov_info_t;  } syncprov_info_t;
   
 typedef struct opcookie {  typedef struct opcookie {
Line 776  syncprov_sendresp( Operation *op, opcook Line 775  syncprov_sendresp( Operation *op, opcook
   
         SlapReply rs = { REP_SEARCH };          SlapReply rs = { REP_SEARCH };
         LDAPControl *ctrls[2];          LDAPControl *ctrls[2];
         struct berval cookie = BER_BVNULL, csns[2];          struct berval cookie, csns[2];
         Entry e_uuid = {0};          Entry e_uuid = {0};
         Attribute a_uuid = {0};          Attribute a_uuid = {0};
   
Line 784  syncprov_sendresp( Operation *op, opcook Line 783  syncprov_sendresp( Operation *op, opcook
                 return SLAPD_ABANDON;                  return SLAPD_ABANDON;
   
         ctrls[1] = NULL;          ctrls[1] = NULL;
         if ( !BER_BVISNULL( &opc->sctxcsn )) {          csns[0] = opc->sctxcsn;
                 csns[0] = opc->sctxcsn;          BER_BVZERO( &csns[1] );
                 BER_BVZERO( &csns[1] );          slap_compose_sync_cookie( op, &cookie, csns, so->s_rid, slap_serverID ? slap_serverID : -1 );
                 slap_compose_sync_cookie( op, &cookie, csns, so->s_rid, slap_serverID ? slap_serverID : -1 );  
         }  
   
 #ifdef LDAP_DEBUG  #ifdef LDAP_DEBUG
         if ( !BER_BVISNULL( &cookie )) {          if ( so->s_sid > 0 ) {
                 if ( so->s_sid > 0 ) {                  Debug( LDAP_DEBUG_SYNC, "syncprov_sendresp: to=%03x, cookie=%s\n",
                         Debug( LDAP_DEBUG_SYNC, "syncprov_sendresp: to=%03x, cookie=%s\n",                          so->s_sid, cookie.bv_val, 0 );
                                 so->s_sid, cookie.bv_val , 0 );          } else {
                 } else {                  Debug( LDAP_DEBUG_SYNC, "syncprov_sendresp: cookie=%s\n",
                         Debug( LDAP_DEBUG_SYNC, "syncprov_sendresp: cookie=%s\n",                          cookie.bv_val, 0, 0 );
                                 cookie.bv_val, 0, 0 );          }
                 }  
         }                 
 #endif  #endif
   
         e_uuid.e_attrs = &a_uuid;          e_uuid.e_attrs = &a_uuid;
Line 807  syncprov_sendresp( Operation *op, opcook Line 802  syncprov_sendresp( Operation *op, opcook
         a_uuid.a_nvals = &opc->suuid;          a_uuid.a_nvals = &opc->suuid;
         rs.sr_err = syncprov_state_ctrl( op, &rs, &e_uuid,          rs.sr_err = syncprov_state_ctrl( op, &rs, &e_uuid,
                 mode, ctrls, 0, 1, &cookie );                  mode, ctrls, 0, 1, &cookie );
         if ( !BER_BVISNULL( &cookie )) {          op->o_tmpfree( cookie.bv_val, op->o_tmpmemctx );
                 op->o_tmpfree( cookie.bv_val, op->o_tmpmemctx );  
         }  
   
         rs.sr_ctrls = ctrls;          rs.sr_ctrls = ctrls;
         op->o_bd->bd_info = (BackendInfo *)on->on_info;          op->o_bd->bd_info = (BackendInfo *)on->on_info;
Line 1253  syncprov_matchops( Operation *op, opcook Line 1246  syncprov_matchops( Operation *op, opcook
                         oh = *op->o_hdr;                          oh = *op->o_hdr;
                         oh.oh_conn = ss->s_op->o_conn;                          oh.oh_conn = ss->s_op->o_conn;
                         oh.oh_connid = ss->s_op->o_connid;                          oh.oh_connid = ss->s_op->o_connid;
                         op2.o_bd = op->o_bd->bd_self;  
                         op2.o_hdr = &oh;                          op2.o_hdr = &oh;
                         op2.o_extra = op->o_extra;                          op2.o_extra = op->o_extra;
                         op2.o_callback = NULL;  
                         rc = test_filter( &op2, e, ss->s_op->ors_filter );                          rc = test_filter( &op2, e, ss->s_op->ors_filter );
                 }                  }
   
Line 1325  syncprov_op_cleanup( Operation *op, Slap Line 1316  syncprov_op_cleanup( Operation *op, Slap
         /* Remove op from lock table */          /* Remove op from lock table */
         mt = opc->smt;          mt = opc->smt;
         if ( mt ) {          if ( mt ) {
                 ldap_pvt_thread_mutex_lock( &mt->mt_mutex );                  modinst *mi = mt->mt_mods;
                 mt->mt_mods = mt->mt_mods->mi_next;  
                 /* If there are more, promote the next one */                  /* If there are more, promote the next one */
                 if ( mt->mt_mods ) {                  if ( mi->mi_next ) {
                           ldap_pvt_thread_mutex_lock( &mt->mt_mutex );
                           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_unlock( &mt->mt_mutex );  
                         ldap_pvt_thread_mutex_lock( &si->si_mods_mutex );                          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( &si->si_mods_mutex );
Line 1646  syncprov_op_response( Operation *op, Sla Line 1638  syncprov_op_response( Operation *op, Sla
                 char cbuf[LDAP_LUTIL_CSNSTR_BUFSIZE];                  char cbuf[LDAP_LUTIL_CSNSTR_BUFSIZE];
                 int do_check = 0, have_psearches, foundit, csn_changed = 0;                  int do_check = 0, have_psearches, foundit, csn_changed = 0;
   
                 ldap_pvt_thread_mutex_lock( &si->si_resp_mutex );  
   
                 /* Update our context CSN */                  /* Update our context CSN */
                 cbuf[0] = '\0';                  cbuf[0] = '\0';
                 maxcsn.bv_val = cbuf;                  maxcsn.bv_val = cbuf;
Line 1701  syncprov_op_response( Operation *op, Sla Line 1691  syncprov_op_response( Operation *op, Sla
                                         }                                          }
                                 }                                  }
                         }                          }
                         goto leave;                          return SLAP_CB_CONTINUE;
                 }                  }
   
                 slap_get_commit_csn( op, &maxcsn, &foundit );                  slap_get_commit_csn( op, &maxcsn, &foundit );
Line 1754  syncprov_op_response( Operation *op, Sla Line 1744  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 ( op->o_dont_replicate ) {                  if ( op->o_dont_replicate ) {
                         ldap_pvt_thread_rdwr_wunlock( &si->si_csn_rwlock );                          ldap_pvt_thread_rdwr_wunlock( &si->si_csn_rwlock );
                         goto leave;                          return SLAP_CB_CONTINUE;
                 }                  }
   
                 si->si_numops++;                  si->si_numops++;
Line 1821  syncprov_op_response( Operation *op, Sla Line 1811  syncprov_op_response( Operation *op, Sla
                 if ( si->si_logs && op->o_tag != LDAP_REQ_ADD ) {                  if ( si->si_logs && op->o_tag != LDAP_REQ_ADD ) {
                         syncprov_add_slog( op );                          syncprov_add_slog( op );
                 }                  }
 leave:          ldap_pvt_thread_mutex_unlock( &si->si_resp_mutex );  
         }          }
         return SLAP_CB_CONTINUE;          return SLAP_CB_CONTINUE;
 }  }
Line 1948  syncprov_op_mod( Operation *op, SlapRepl Line 1938  syncprov_op_mod( Operation *op, SlapRepl
                 mt = avl_find( si->si_mods, &mtdummy, sp_avl_cmp );                  mt = avl_find( si->si_mods, &mtdummy, sp_avl_cmp );
                 if ( mt ) {                  if ( mt ) {
                         ldap_pvt_thread_mutex_lock( &mt->mt_mutex );                          ldap_pvt_thread_mutex_lock( &mt->mt_mutex );
                         if ( mt->mt_mods == NULL ) {  
                                 /* Cannot reuse this mt, as another thread is about  
                                  * to release it in syncprov_op_cleanup.  
                                  */  
                                 ldap_pvt_thread_mutex_unlock( &mt->mt_mutex );  
                                 mt = NULL;  
                         }  
                 }  
                 if ( mt ) {  
                         ldap_pvt_thread_mutex_unlock( &si->si_mods_mutex );                          ldap_pvt_thread_mutex_unlock( &si->si_mods_mutex );
                         mt->mt_tail->mi_next = mi;                          mt->mt_tail->mi_next = mi;
                         mt->mt_tail = mi;                          mt->mt_tail = mi;
Line 2222  syncprov_search_response( Operation *op, Line 2203  syncprov_search_response( Operation *op,
                                 LDAP_SYNC_ADD, rs->sr_ctrls, 0, 0, NULL );                                  LDAP_SYNC_ADD, rs->sr_ctrls, 0, 0, NULL );
                 }                  }
         } else if ( rs->sr_type == REP_RESULT && rs->sr_err == LDAP_SUCCESS ) {          } else if ( rs->sr_type == REP_RESULT && rs->sr_err == LDAP_SUCCESS ) {
                 struct berval cookie = BER_BVNULL;                  struct berval cookie;
   
                 if ( ( ss->ss_flags & SS_CHANGED ) &&                  if ( ss->ss_flags & SS_CHANGED ) {
                         ss->ss_ctxcsn && !BER_BVISNULL( &ss->ss_ctxcsn[0] )) {  
                         slap_compose_sync_cookie( op, &cookie, ss->ss_ctxcsn,                          slap_compose_sync_cookie( op, &cookie, ss->ss_ctxcsn,
                                 srs->sr_state.rid, slap_serverID ? slap_serverID : -1 );                                  srs->sr_state.rid, slap_serverID ? slap_serverID : -1 );
   
Line 2249  syncprov_search_response( Operation *op, Line 2229  syncprov_search_response( Operation *op,
                                 LDAP_TAG_SYNC_REFRESH_PRESENT : LDAP_TAG_SYNC_REFRESH_DELETE,                                  LDAP_TAG_SYNC_REFRESH_PRESENT : LDAP_TAG_SYNC_REFRESH_DELETE,
                                 ( ss->ss_flags & SS_CHANGED ) ? &cookie : NULL,                                  ( ss->ss_flags & SS_CHANGED ) ? &cookie : NULL,
                                 1, NULL, 0 );                                  1, NULL, 0 );
                         if ( !BER_BVISNULL( &cookie ))                          if ( ss->ss_flags & SS_CHANGED )
                                 op->o_tmpfree( cookie.bv_val, op->o_tmpmemctx );                                  op->o_tmpfree( cookie.bv_val, op->o_tmpmemctx );
   
                         /* Detach this Op from frontend control */                          /* Detach this Op from frontend control */
Line 2978  syncprov_db_init( Line 2958  syncprov_db_init(
         ldap_pvt_thread_rdwr_init( &si->si_csn_rwlock );          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 );
         ldap_pvt_thread_mutex_init( &si->si_resp_mutex );  
   
         csn_anlist[0].an_desc = slap_schema.si_ad_entryCSN;          csn_anlist[0].an_desc = slap_schema.si_ad_entryCSN;
         csn_anlist[0].an_name = slap_schema.si_ad_entryCSN->ad_cname;          csn_anlist[0].an_name = slap_schema.si_ad_entryCSN->ad_cname;
Line 3016  syncprov_db_destroy( Line 2995  syncprov_db_destroy(
                         ber_bvarray_free( si->si_ctxcsn );                          ber_bvarray_free( si->si_ctxcsn );
                 if ( si->si_sids )                  if ( si->si_sids )
                         ch_free( si->si_sids );                          ch_free( si->si_sids );
                 ldap_pvt_thread_mutex_destroy( &si->si_resp_mutex );  
                 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_rdwr_destroy( &si->si_csn_rwlock );                  ldap_pvt_thread_rdwr_destroy( &si->si_csn_rwlock );

Removed from v.1.147.2.60  
changed lines
  Added in v.1.281


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