X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fentry.c;h=f7a1fb7b8d1a320ec153f93cc437c51976f052a6;hb=2c4b2b5566e14bbda986be58733d16c94f8b5e35;hp=e83ed0000d1cfe2f3fb7df18c6556cbff45ddb55;hpb=923bea9e1497192e8891143abf8fb6560115a801;p=openldap

diff --git a/servers/slapd/entry.c b/servers/slapd/entry.c
index e83ed0000d..f7a1fb7b8d 100644
--- a/servers/slapd/entry.c
+++ b/servers/slapd/entry.c
@@ -2,7 +2,7 @@
 /* $OpenLDAP$ */
 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
  *
- * Copyright 1998-2005 The OpenLDAP Foundation.
+ * Copyright 1998-2006 The OpenLDAP Foundation.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -36,8 +36,8 @@
 #include "slap.h"
 #include "ldif.h"
 
-static unsigned char	*ebuf;	/* buf returned by entry2str		 */
-static unsigned char	*ecur;	/* pointer to end of currently used ebuf */
+static char		*ebuf;	/* buf returned by entry2str		 */
+static char		*ecur;	/* pointer to end of currently used ebuf */
 static int		emaxsize;/* max size of ebuf			 */
 
 /*
@@ -47,18 +47,53 @@ const Entry slap_entry_root = {
 	NOID, { 0, "" }, { 0, "" }, NULL, 0, { 0, "" }, NULL
 };
 
+/*
+ * these mutexes must be used when calling the entry2str()
+ * routine since it returns a pointer to static data.
+ */
+ldap_pvt_thread_mutex_t	entry2str_mutex;
+
 static const struct berval dn_bv = BER_BVC("dn");
 
+/*
+ * Entry free list
+ *
+ * Allocate in chunks, minimum of 1000 at a time.
+ */
+#define	CHUNK_SIZE	1000
+typedef struct slap_list {
+	struct slap_list *next;
+} slap_list;
+static slap_list *entry_chunks;
+static Entry *entry_list;
+static ldap_pvt_thread_mutex_t entry_mutex;
+
 int entry_destroy(void)
 {
+	slap_list *e;
 	if ( ebuf ) free( ebuf );
 	ebuf = NULL;
 	ecur = NULL;
 	emaxsize = 0;
-	return 0;
+
+	for ( e=entry_chunks; e; e=entry_chunks ) {
+		entry_chunks = e->next;
+		free( e );
+	}
+
+	ldap_pvt_thread_mutex_destroy( &entry_mutex );
+	ldap_pvt_thread_mutex_destroy( &entry2str_mutex );
+	return attr_destroy();
 }
 
 
+int entry_init(void)
+{
+	ldap_pvt_thread_mutex_init( &entry2str_mutex );
+	ldap_pvt_thread_mutex_init( &entry_mutex );
+	return attr_init();
+}
+
 Entry *
 str2entry( char *s )
 {
@@ -70,7 +105,6 @@ str2entry2( char *s, int checkvals )
 {
 	int rc;
 	Entry		*e;
-	struct berval	*nvalsp;
 	struct berval	*type, *vals, *nvals;
 	char 	*freeval;
 	AttributeDescription *ad, *ad_prev;
@@ -98,8 +132,7 @@ str2entry2( char *s, int checkvals )
 	Debug( LDAP_DEBUG_TRACE, "=> str2entry: \"%s\"\n",
 		s ? s : "NULL", 0, 0 );
 
-	/* initialize reader/writer lock */
-	e = (Entry *) ch_calloc( 1, sizeof(Entry) );
+	e = entry_alloc();
 
 	if( e == NULL ) {
 		Debug( LDAP_DEBUG_ANY,
@@ -217,10 +250,10 @@ str2entry2( char *s, int checkvals )
 					goto fail;
 				}
 
-				rc = slap_bv2undef_ad( type+i, &ad, &text );
+				rc = slap_bv2undef_ad( type+i, &ad, &text, 0 );
 				if( rc != LDAP_SUCCESS ) {
 					Debug( LDAP_DEBUG_ANY,
-						"<= str2entry: str2undef_ad(%s): %s\n",
+						"<= str2entry: slap_str2undef_ad(%s): %s\n",
 							type[i].bv_val, text, 0 );
 					goto fail;
 				}
@@ -229,8 +262,9 @@ str2entry2( char *s, int checkvals )
 
 		if (( ad_prev && ad != ad_prev ) || ( i == lines )) {
 			int j, k;
-			atail->a_next = (Attribute *) ch_malloc( sizeof(Attribute) );
+			atail->a_next = attr_alloc( NULL );
 			atail = atail->a_next;
+			atail->a_flags = 0;
 			atail->a_desc = ad_prev;
 			atail->a_vals = ch_malloc( (attr_cnt + 1) * sizeof(struct berval));
 			if( ad_prev->ad_type->sat_equality &&
@@ -268,15 +302,15 @@ str2entry2( char *s, int checkvals )
 			slap_syntax_transform_func *pretty =
 				ad->ad_type->sat_syntax->ssyn_pretty;
 
-			if( pretty ) {
-				rc = pretty( ad->ad_type->sat_syntax,
+			if ( pretty ) {
+				rc = ordered_value_pretty( ad,
 					&vals[i], &pval, NULL );
 
-			} else if( validate ) {
+			} else if ( validate ) {
 				/*
 			 	 * validate value per syntax
 			 	 */
-				rc = validate( ad->ad_type->sat_syntax, &vals[i] );
+				rc = ordered_value_validate( ad, &vals[i], LDAP_MOD_ADD );
 
 			} else {
 				Debug( LDAP_DEBUG_ANY,
@@ -303,16 +337,16 @@ str2entry2( char *s, int checkvals )
 			}
 		}
 
-		if( ad->ad_type->sat_equality &&
+		if ( ad->ad_type->sat_equality &&
 			ad->ad_type->sat_equality->smr_normalize )
 		{
-			rc = ad->ad_type->sat_equality->smr_normalize(
+			rc = ordered_value_normalize(
 				SLAP_MR_VALUE_OF_ATTRIBUTE_SYNTAX,
-				ad->ad_type->sat_syntax,
+				ad,
 				ad->ad_type->sat_equality,
 				&vals[i], &nvals[i], NULL );
 
-			if( rc ) {
+			if ( rc ) {
 				Debug( LDAP_DEBUG_ANY,
 			   		"<= str2entry NULL (smr_normalize %d)\n", rc, 0, 0 );
 				goto fail;
@@ -347,7 +381,7 @@ fail:
 		while ( ecur + (n) > ebuf + emaxsize ) { \
 			ptrdiff_t	offset; \
 			offset = (int) (ecur - ebuf); \
-			ebuf = (unsigned char *) ch_realloc( (char *) ebuf, \
+			ebuf = ch_realloc( ebuf, \
 				emaxsize + GRABSIZE ); \
 			emaxsize += GRABSIZE; \
 			ecur = ebuf + offset; \
@@ -379,7 +413,7 @@ entry2str(
 		/* put "dn: <dn>" */
 		tmplen = e->e_name.bv_len;
 		MAKE_SPACE( LDIF_SIZE_NEEDED( 2, tmplen ));
-		ldif_sput( (char **) &ecur, LDIF_PUT_VALUE, "dn", e->e_dn, tmplen );
+		ldif_sput( &ecur, LDIF_PUT_VALUE, "dn", e->e_dn, tmplen );
 	}
 
 	/* put the attributes */
@@ -389,7 +423,7 @@ entry2str(
 			bv = &a->a_vals[i];
 			tmplen = a->a_desc->ad_cname.bv_len;
 			MAKE_SPACE( LDIF_SIZE_NEEDED( tmplen, bv->bv_len ));
-			ldif_sput( (char **) &ecur, LDIF_PUT_VALUE,
+			ldif_sput( &ecur, LDIF_PUT_VALUE,
 				a->a_desc->ad_cname.bv_val,
 				bv->bv_val, bv->bv_len );
 		}
@@ -398,7 +432,7 @@ entry2str(
 	*ecur = '\0';
 	*len = ecur - ebuf;
 
-	return( (char *) ebuf );
+	return( ebuf );
 }
 
 void
@@ -409,26 +443,27 @@ entry_clean( Entry *e )
 
 	/* e_private must be freed by the caller */
 	assert( e->e_private == NULL );
-	e->e_private = NULL;
 
 	/* free DNs */
 	if ( !BER_BVISNULL( &e->e_name ) ) {
 		free( e->e_name.bv_val );
-		BER_BVZERO( &e->e_name );
 	}
 	if ( !BER_BVISNULL( &e->e_nname ) ) {
 		free( e->e_nname.bv_val );
-		BER_BVZERO( &e->e_nname );
 	}
 
 	if ( !BER_BVISNULL( &e->e_bv ) ) {
 		free( e->e_bv.bv_val );
-		BER_BVZERO( &e->e_bv );
+	}
+
+	if ( &e->e_abv ) {
+		free( e->e_abv );
 	}
 
 	/* free attributes */
 	attrs_free( e->e_attrs );
-	e->e_attrs = NULL;
+
+	memset(e, 0, sizeof(Entry));
 }
 
 void
@@ -436,9 +471,52 @@ entry_free( Entry *e )
 {
 	entry_clean( e );
 
-	free( e );
+	ldap_pvt_thread_mutex_lock( &entry_mutex );
+	e->e_private = entry_list;
+	entry_list = e;
+	ldap_pvt_thread_mutex_unlock( &entry_mutex );
+}
+
+int
+entry_prealloc( int num )
+{
+	Entry *e;
+	slap_list *s;
+
+	if (!num) return 0;
+
+	s = ch_calloc( 1, sizeof(slap_list) + num * sizeof(Entry));
+	s->next = entry_chunks;
+	entry_chunks = s;
+
+	e = (Entry *)(s+1);
+	for ( ;num>1; num--) {
+		e->e_private = e+1;
+		e++;
+	}
+	e->e_private = entry_list;
+	entry_list = (Entry *)(s+1);
+
+	return 0;
+}
+
+Entry *
+entry_alloc( void )
+{
+	Entry *e;
+
+	ldap_pvt_thread_mutex_lock( &entry_mutex );
+	if ( !entry_list )
+		entry_prealloc( CHUNK_SIZE );
+	e = entry_list;
+	entry_list = e->e_private;
+	e->e_private = NULL;
+	ldap_pvt_thread_mutex_unlock( &entry_mutex );
+
+	return e;
 }
 
+
 /*
  * These routines are used only by Backend.
  *
@@ -616,8 +694,8 @@ int entry_encode(Entry *e, struct berval *bv)
 		*ptr++ = '\0';
 		if (a->a_vals) {
 			for (i=0; a->a_vals[i].bv_val; i++);
-				entry_putlen(&ptr, i);
-				for (i=0; a->a_vals[i].bv_val; i++) {
+			entry_putlen(&ptr, i);
+			for (i=0; a->a_vals[i].bv_val; i++) {
 				entry_putlen(&ptr, a->a_vals[i].bv_len);
 				AC_MEMCPY(ptr, a->a_vals[i].bv_val,
 					a->a_vals[i].bv_len);
@@ -679,19 +757,9 @@ int entry_decode(struct berval *bv, Entry **e)
 			"entry_decode: value count was zero\n", 0, 0, 0);
 		return LDAP_OTHER;
 	}
-	i = sizeof(Entry) + (nattrs * sizeof(Attribute)) +
-		(nvals * sizeof(struct berval));
-#ifdef SLAP_ZONE_ALLOC
-	x = slap_zn_calloc(1, i + bv->bv_len, ctx);
-	AC_MEMCPY((char*)x + i, bv->bv_val, bv->bv_len);
-	bv->bv_val = (char*)x + i;
-	ptr = (unsigned char *)bv->bv_val;
-	/* pointer is reset, now advance past nattrs and nvals again */
-	entry_getlen(&ptr);
-	entry_getlen(&ptr);
-#else
-	x = ch_calloc(1, i);
-#endif
+	x = entry_alloc();
+	x->e_attrs = attrs_alloc( nattrs );
+	x->e_abv = ch_malloc( nvals * sizeof( struct berval ));
 	i = entry_getlen(&ptr);
 	x->e_name.bv_val = (char *) ptr;
 	x->e_name.bv_len = i;
@@ -705,45 +773,33 @@ int entry_decode(struct berval *bv, Entry **e)
 		x->e_dn, 0, 0 );
 	x->e_bv = *bv;
 
-	/* A valid entry must have at least one attr, so this
-	 * pointer can never be NULL
-	 */
-	x->e_attrs = (Attribute *)(x+1);
-	bptr = (BerVarray)x->e_attrs;
-	a = NULL;
+	a = x->e_attrs;
+	bptr = x->e_abv;
 
 	while ((i = entry_getlen(&ptr))) {
 		struct berval bv;
 		bv.bv_len = i;
 		bv.bv_val = (char *) ptr;
-		if (a) {
-			a->a_next = (Attribute *)bptr;
-		}
-		a = (Attribute *)bptr;
 		ad = NULL;
 		rc = slap_bv2ad( &bv, &ad, &text );
 
 		if( rc != LDAP_SUCCESS ) {
 			Debug( LDAP_DEBUG_TRACE,
 				"<= entry_decode: str2ad(%s): %s\n", ptr, text, 0 );
-			rc = slap_bv2undef_ad( &bv, &ad, &text );
+			rc = slap_bv2undef_ad( &bv, &ad, &text, 0 );
 
 			if( rc != LDAP_SUCCESS ) {
 				Debug( LDAP_DEBUG_ANY,
-					"<= entry_decode: str2undef_ad(%s): %s\n",
+					"<= entry_decode: slap_str2undef_ad(%s): %s\n",
 						ptr, text, 0 );
 				return rc;
 			}
 		}
 		ptr += i + 1;
 		a->a_desc = ad;
-		bptr = (BerVarray)(a+1);
-		a->a_vals = bptr;
-		a->a_flags = 0;
-#ifdef LDAP_COMP_MATCH
-		a->a_comp_data = NULL;
-#endif
+		a->a_flags = SLAP_ATTR_DONT_FREE_DATA | SLAP_ATTR_DONT_FREE_VALS;
 		count = j = entry_getlen(&ptr);
+		a->a_vals = bptr;
 
 		while (j) {
 			i = entry_getlen(&ptr);
@@ -774,12 +830,12 @@ int entry_decode(struct berval *bv, Entry **e)
 		} else {
 			a->a_nvals = a->a_vals;
 		}
+		a = a->a_next;
 		nattrs--;
 		if ( !nattrs )
 			break;
 	}
 
-	if (a) a->a_next = NULL;
 	Debug(LDAP_DEBUG_TRACE, "<= entry_decode(%s)\n",
 		x->e_dn, 0, 0 );
 	*e = x;
@@ -790,7 +846,7 @@ Entry *entry_dup( Entry *e )
 {
 	Entry *ret;
 
-	ret = (Entry *)ch_calloc( 1, sizeof(*ret) );
+	ret = entry_alloc();
 
 	ret->e_id = e->e_id;
 	ber_dupbv( &ret->e_name, &e->e_name );