Skip site navigation (1)Skip section navigation (2)
Date:      Wed, 31 Aug 2005 22:32:27 GMT
From:      soc-bushman <soc-bushman@FreeBSD.org>
To:        Perforce Change Reviews <perforce@freebsd.org>
Subject:   PERFORCE change 82946 for review
Message-ID:  <200508312232.j7VMWRlK046203@repoman.freebsd.org>

next in thread | raw e-mail | index | archive | help
http://perforce.freebsd.org/chv.cgi?CH=82946

Change 82946 by soc-bushman@soc-bushman_stinger on 2005/08/31 22:31:58

	GT4 modified - not tested yet

Affected files ...

.. //depot/projects/soc2005/nsswitch_cached/tests/gt4_test/configure.in#1 add
.. //depot/projects/soc2005/nsswitch_cached/tests/gt4_test/globus_gss_assist.h#1 add
.. //depot/projects/soc2005/nsswitch_cached/tests/gt4_test/gridmap.c#1 add
.. //depot/projects/soc2005/nsswitch_cached/tests/gt4_test/port/Makefile#2 edit
.. //depot/projects/soc2005/nsswitch_cached/tests/src.inproc/include/nscache.h#2 edit
.. //depot/projects/soc2005/nsswitch_cached/tests/src.inproc/include/nscachedcli.h#2 delete
.. //depot/projects/soc2005/nsswitch_cached/tests/src.inproc/include/nsswitch.h#2 edit
.. //depot/projects/soc2005/nsswitch_cached/tests/src.inproc/lib/libc/net/Makefile.inc#2 edit
.. //depot/projects/soc2005/nsswitch_cached/tests/src.inproc/lib/libc/net/nscache.c#2 edit
.. //depot/projects/soc2005/nsswitch_cached/tests/src.inproc/lib/libc/net/nscachedcli.c#2 delete

Differences ...

==== //depot/projects/soc2005/nsswitch_cached/tests/gt4_test/port/Makefile#2 (text+ko) ====


==== //depot/projects/soc2005/nsswitch_cached/tests/src.inproc/include/nscache.h#2 (text+ko) ====

@@ -24,27 +24,27 @@
  * SUCH DAMAGE.
  *
  */
-
+ 
 #ifndef __NS_CACHE_H__
 #define __NS_CACHE_H__
 
+#include <nscachelib.h>
+
 typedef int (*nss_cache_id_func_t)(char *, size_t, va_list, void *);
-typedef int (*nss_cache_marshal_func_t)(char *, size_t *, void *, va_list, 
-	void *);
-typedef int (*nss_cache_unmarshal_func_t)(char *, size_t, void *, va_list, 
-	void *);
+typedef int (*nss_cache_marshal_func_t)(char *, size_t *, void *, va_list, void *);
+typedef int (*nss_cache_unmarshal_func_t)(char *, size_t, void *, va_list, void *);
 
-typedef	void	(*nss_set_mp_ws_func_t)(cached_mp_write_session);
-typedef	cached_mp_write_session	(*nss_get_mp_ws_func_t)(void);
+typedef	void	(*nss_set_mp_ws_func_t)(cache_mp_write_session);
+typedef	cache_mp_write_session	(*nss_get_mp_ws_func_t)(void);
 
-typedef void	(*nss_set_mp_rs_func_t)(cached_mp_read_session);
-typedef cached_mp_read_session	(*nss_get_mp_rs_func_t)(void);
+typedef void	(*nss_set_mp_rs_func_t)(cache_mp_read_session);
+typedef cache_mp_read_session	(*nss_get_mp_rs_func_t)(void);
 
 typedef struct _nss_cache_info {
 	char			*entry_name;
 	void			*mdata;
 	
-	nss_cache_id_func_t			id_func;
+	nss_cache_id_func_t		id_func;
 	nss_cache_marshal_func_t	marshal_func;
 	nss_cache_unmarshal_func_t	unmarshal_func;
 	
@@ -57,8 +57,8 @@
 
 #define NSS_MP_CACHE_HANDLING(name)					\
 struct name##_mp_state {						\
-	cached_mp_write_session	mp_write_session;			\
-	cached_mp_read_session	mp_read_session;			\
+	cache_mp_write_session	mp_write_session;			\
+	cache_mp_read_session	mp_read_session;			\
 };									\
 									\
 static void								\
@@ -66,16 +66,16 @@
 	struct name##_mp_state	*mp_state;				\
 									\
 	mp_state = (struct name##_mp_state *)s;				\
-	if (mp_state->mp_write_session != INVALID_CACHED_MP_WRITE_SESSION)\
-		abandon_cached_mp_write_session(mp_state->mp_write_session);\
+	if (mp_state->mp_write_session != INVALID_CACHE_MP_WRITE_SESSION)\
+		abandon_cache_mp_write_session(mp_state->mp_write_session);\
 									\
-	if (mp_state->mp_read_session != INVALID_CACHED_MP_READ_SESSION)\
-		close_cached_mp_read_session(mp_state->mp_read_session);	\
+	if (mp_state->mp_read_session != INVALID_CACHE_MP_READ_SESSION)	\
+		close_cache_mp_read_session(mp_state->mp_read_session);	\
 }									\
 NSS_TLS_HANDLING(name##_mp);						\
 									\
 static void								\
-name##_set_mp_ws(cached_mp_write_session ws)				\
+name##_set_mp_ws(cache_mp_write_session ws)				\
 {									\
 	struct name##_mp_state	*mp_state;				\
 	int	res;							\
@@ -87,7 +87,7 @@
 	mp_state->mp_write_session = ws;				\
 }									\
 									\
-static cached_mp_write_session						\
+static cache_mp_write_session						\
 name##_get_mp_ws(void)							\
 {									\
 	struct name##_mp_state	*mp_state;				\
@@ -95,13 +95,13 @@
 									\
 	res = name##_mp_getstate(&mp_state);				\
 	if (res != 0)							\
-		return (INVALID_CACHED_MP_WRITE_SESSION);		\
+		return (INVALID_CACHE_MP_WRITE_SESSION);		\
 									\
 	return (mp_state->mp_write_session);				\
 }									\
 									\
 static void								\
-name##_set_mp_rs(cached_mp_read_session rs)				\
+name##_set_mp_rs(cache_mp_read_session rs)				\
 {									\
 	struct name##_mp_state	*mp_state;				\
 	int	res;							\
@@ -113,7 +113,7 @@
 	mp_state->mp_read_session = rs;					\
 }									\
 									\
-static cached_mp_read_session						\
+static cache_mp_read_session						\
 name##_get_mp_rs(void)							\
 {									\
 	struct name##_mp_state	*mp_state;				\
@@ -121,7 +121,7 @@
 									\
 	res = name##_mp_getstate(&mp_state);				\
 	if (res != 0)							\
-		return (INVALID_CACHED_MP_READ_SESSION);		\
+		return (INVALID_CACHE_MP_READ_SESSION);			\
 									\
 	return (mp_state->mp_read_session);				\
 }																				
@@ -132,15 +132,17 @@
 	{#name, mdata, NULL, mf, uf, name##_set_mp_ws, name##_get_mp_ws, \
 		name##_set_mp_rs, name##_get_mp_rs }
 
-#define NS_CACHE_CB(cinfo) {NSSRC_CACHE, nss_cache_handler, (void *)(cinfo) },
+#define NS_CACHE_CB(cinfo) {NSSRC_CACHE, nss_cache_handler, (void *)(cinfo) }
 
-/* args are: current pointer, current buffer, initial buffer, pointer type */
+/* 
+ * arguments are: current pointer, current buffer, initial buffer, pointer type 
+ */
 #define NS_APPLY_OFFSET(cp, cb, ib, p_type)				\
-	if ((cp) != NULL)														\
+	if ((cp) != NULL)						\
 		(cp) = (p_type)((char *)(cb) + (size_t)(cp) - (size_t)(ib))
 /* 
- * gets new pointer from the marshalled buffer by uisng initial address 	
- * and initial buffer address 
+ * gets new pointer from the marshalled buffer by uisng initial address and 
+ * initial buffer address 
  */
 #define NS_GET_NEWP(cp, cb, ib)						\
 	((char *)(cb) + (size_t)(cp) - (size_t)(ib))

==== //depot/projects/soc2005/nsswitch_cached/tests/src.inproc/include/nsswitch.h#2 (text+ko) ====

@@ -196,7 +196,7 @@
 };
 
 #ifdef NS_CACHING
-#include "nscachedcli.h"
+#include "nscachelib.h"
 #include "nscache.h"
 #endif /* NS_CACHING */
 

==== //depot/projects/soc2005/nsswitch_cached/tests/src.inproc/lib/libc/net/Makefile.inc#2 (text+ko) ====

@@ -16,7 +16,7 @@
 	inet_netof.c inet_network.c inet_ntoa.c inet_ntop.c \
 	inet_pton.c ip6opt.c linkaddr.c map_v4v6.c name6.c \
 	ns_name.c ns_netint.c ns_parse.c ns_print.c ns_ttl.c \
-	nscache.c nscachedcli.c	nsdispatch.c nslexer.c nsparser.c \
+	nscache.c nscachelib.c	nscachepl.c nsdispatch.c nslexer.c nsparser.c \
 	nss_compat.c nsap_addr.c rcmd.c rcmdsh.c recv.c res_comp.c res_data.c \
 	res_debug.c res_init.c res_mkquery.c res_mkupdate.c res_query.c res_send.c \
 	res_update.c rthdr.c send.c sockatmark.c vars.c
@@ -117,4 +117,3 @@
 SRCS+=	hesiod.c 
 MAN+=	hesiod.3
 .endif
-

==== //depot/projects/soc2005/nsswitch_cached/tests/src.inproc/lib/libc/net/nscache.c#2 (text+ko) ====

@@ -25,12 +25,16 @@
  *
  */
  
-#include <nsswitch.h>
+#include "namespace.h"
+#include "nsswitch.h"
+#include <pthread.h>
 #include <stdlib.h>
 #include <string.h>
+#include "un-namespace.h"
 
-#include <nscachedcli.h>
+#include <nscachelib.h>
 #include <nscache.h>
+#include "libc_private.h"
 
 #define NSS_CACHE_KEY_INITIAL_SIZE	(256)
 #define NSS_CACHE_KEY_SIZE_LIMIT	(NSS_CACHE_KEY_INITIAL_SIZE << 4)
@@ -38,33 +42,104 @@
 #define NSS_CACHE_BUFFER_INITIAL_SIZE	(1024)
 #define NSS_CACHE_BUFFER_SIZE_LIMIT	(NSS_CACHE_BUFFER_INITIAL_SIZE << 8)
 
-#define CACHED_SOCKET_PATH			"/var/run/cached"
+#define _MUTEX_LOCK(x)		if (__isthreaded) _pthread_mutex_lock(x)
+#define _MUTEX_UNLOCK(x)	if (__isthreaded) _pthread_mutex_unlock(x)
+
+static cache s_cache = INVALID_CACHE;
+static pthread_mutex_t s_cache_lock = PTHREAD_MUTEX_INITIALIZER;
+
+void
+get_time_func(struct timeval *time)
+{
+	/* 
+	* WARNING: We use the gettimeofday for simplicity. 
+    	* This patch is intended to be used basically for testing and 
+	* benchmarking purposes. Gettimeofday() is potentially dangerous,
+	* when time goes backwards (for example season time change). In
+	* such cases cache can be corrupted.
+	*/
+    
+    gettimeofday(time, NULL);
+}
+
+static void
+register_global_ce_entry(const char *name)
+{
+	struct common_cache_entry_params params;
+	    
+	memset(&params, 0, sizeof(struct common_cache_entry_params));
+	params.entry_type = CET_COMMON;
+	params.entry_name = (char *)name;
+	params.policy = CPT_LRU;
+	
+	register_cache_entry(s_cache, (struct cache_entry_params *)&params);		
+}
+
+static void
+register_global_ce_mp_entry(const char *name)
+{
+	struct mp_cache_entry_params params;
+		
+	memset(&params, 0, sizeof(struct mp_cache_entry_params));
+	params.entry_type = CET_MULTIPART;
+	params.entry_name = (char *)name;
+
+	register_cache_entry(s_cache, (struct cache_entry_params *)&params);		
+}
+
+static void
+init_global_cache()
+{
+	struct cache_params params;
+
+	memset(&params, 0, sizeof(struct cache_params));		
+	params.get_time_func = get_time_func;
+	s_cache = init_cache(&params);
+	
+	register_global_ce_entry("passwd");
+	register_global_ce_mp_entry("passwd_mp");
+	register_global_ce_entry("group");
+	register_global_ce_mp_entry("group_mp");
+	register_global_ce_entry("services");
+	register_global_ce_mp_entry("services_mp");
+	register_global_ce_entry("rpc");
+	register_global_ce_mp_entry("rpc_mp");
+	register_global_ce_entry("protocols");
+	register_global_ce_mp_entry("protocols_mp");
+	register_global_ce_entry("hosts");
+}
 
 int
 nss_cache_handler(void *retval, void *mdata, va_list ap)
 {
+
 	return (NS_UNAVAIL);
 }
 
 int
 nss_common_cache_read(void *retval, void *mdata, va_list ap)
 {
-	struct cached_connection_params params;
-	cached_connection connection;
+    	cache_entry	c_entry;
+    
+	char	*buffer;
+	size_t	buffer_size;
 	
-	char *buffer;
-	size_t buffer_size;
-	
-	nss_cache_info const *cache_info;	
-	nss_cache_data *cache_data;
-	va_list ap_new;
-	int res;
+	nss_cache_info const	*cache_info;	
+	nss_cache_data	*cache_data;
+	va_list			ap_new;
+	int			res;
 	
 	cache_data = (nss_cache_data *)mdata;
 	cache_info = cache_data->info;
 	
-	memset(&params, 0, sizeof(struct cached_connection_params));
-	params.socket_path = CACHED_SOCKET_PATH;
+    	_MUTEX_LOCK(&s_cache_lock);
+    	if (s_cache == INVALID_CACHE)
+		init_global_cache();
+	c_entry = find_cache_entry(s_cache, cache_info->entry_name);
+    	_MUTEX_UNLOCK(&s_cache_lock);
+			
+	if (c_entry == NULL)
+	    return (NS_UNAVAIL);
 	
 	cache_data->key = (char *)malloc(NSS_CACHE_KEY_INITIAL_SIZE);
 	memset(cache_data->key, 0, NSS_CACHE_KEY_INITIAL_SIZE);
@@ -73,8 +148,7 @@
 
 	do {
 		res = cache_info->id_func(cache_data->key, 
-	    		cache_data->key_size - 1, 
-			ap_new, cache_info->mdata);
+	    		cache_data->key_size - 1, ap_new, cache_info->mdata);
 		va_end(ap_new);
 		if (res == NS_RETURN) {
 			if (cache_data->key_size > NSS_CACHE_KEY_SIZE_LIMIT)
@@ -99,26 +173,21 @@
 	buffer = (char *)malloc(NSS_CACHE_BUFFER_INITIAL_SIZE);
 	memset(buffer, 0, NSS_CACHE_BUFFER_INITIAL_SIZE);
 	
+	_MUTEX_LOCK(&s_cache_lock);
 	do {
-		connection = open_cached_connection(&params);
-		if (connection == NULL) {
-			res = -1;
-			break;
-		}
-		res = cached_read(connection, cache_info->entry_name, 
-			cache_data->key, buffer, &buffer_size);
-		close_cached_connection(connection);
-		if ((res == -2) && 
-		    (buffer_size < NSS_CACHE_BUFFER_SIZE_LIMIT)) {
+		res = cache_read(c_entry, cache_data->key, buffer, 
+	    		&buffer_size);
+		if ((res == -2) && (buffer_size < NSS_CACHE_BUFFER_SIZE_LIMIT)) {
 			buffer = (char *)realloc(buffer, buffer_size);
 			memset(buffer, 0, buffer_size);
 		}
-	} while (res == -2);				
+	} while (res == -2);
+	_MUTEX_UNLOCK(&s_cache_lock);	
 	
 	if (res == 0) {
 		va_copy(ap_new, ap);
 		res = cache_info->unmarshal_func(buffer, buffer_size, retval, 
-	    		ap_new, cache_info->mdata);
+	    		ap_new,	cache_info->mdata);
 		va_end(ap_new);
 		
 		if (res != NS_SUCCESS) {
@@ -144,16 +213,15 @@
 int
 nss_common_cache_write(void *retval, void *mdata, va_list ap)
 {
-	struct cached_connection_params params;
-	cached_connection connection;
-	
-	char *buffer;
-	size_t buffer_size;
+	cache_entry	c_entry;
+    
+	char	*buffer;
+	size_t	buffer_size;
 
-	nss_cache_info const *cache_info;	
-	nss_cache_data *cache_data;
-	va_list ap_new;
-	int res;
+	nss_cache_info const	*cache_info;	
+	nss_cache_data	*cache_data;
+	va_list			ap_new;
+	int				res;
 	
 	cache_data = (nss_cache_data *)mdata;
 	cache_info = cache_data->info;
@@ -161,15 +229,17 @@
 	if (cache_data->key == NULL)
 		return (NS_UNAVAIL);
 					
-	memset(&params, 0, sizeof(struct cached_connection_params));
-	params.socket_path = CACHED_SOCKET_PATH;
+    	_MUTEX_LOCK(&s_cache_lock);
+    	if (s_cache == INVALID_CACHE)
+		init_global_cache();
+	c_entry = find_cache_entry(s_cache, cache_info->entry_name);
+    	_MUTEX_UNLOCK(&s_cache_lock);
+			
+	if (c_entry == NULL) {
+		free(cache_data->key);	 
+	    	return (NS_UNAVAIL);
+	}
 	
-	connection = open_cached_connection(&params);
-	if (connection == NULL) {
-		free(cache_data->key);
-		return (NS_UNAVAIL);
-	}		
-	
 	buffer_size = NSS_CACHE_BUFFER_INITIAL_SIZE;
 	buffer = (char *)malloc(NSS_CACHE_BUFFER_INITIAL_SIZE);
 	memset(buffer, 0, NSS_CACHE_BUFFER_INITIAL_SIZE);
@@ -194,15 +264,14 @@
 	} while (res == NS_RETURN);
 	
 	if (res != NS_SUCCESS) {
-		close_cached_connection(connection);
 		free(cache_data->key);
 		free(buffer);
 		return (res);
 	}
-	
-	res = cached_write(connection, cache_info->entry_name, cache_data->key, 
-		buffer, buffer_size);
-	close_cached_connection(connection);
+
+	_MUTEX_LOCK(&s_cache_lock);	
+	res = cache_write(c_entry, cache_data->key, buffer, buffer_size);
+	_MUTEX_UNLOCK(&s_cache_lock);
 	
 	free(cache_data->key);
 	free(buffer);
@@ -213,31 +282,38 @@
 int
 nss_mp_cache_read(void *retval, void *mdata, va_list ap)
 {
-	struct cached_connection_params params;
-	cached_mp_read_session rs;
+	cache_entry	c_entry;
+    	cache_mp_read_session	rs;
 	
-	char *buffer;
-	size_t buffer_size;
+	char	*buffer;
+	size_t	buffer_size;
 
-	nss_cache_info const *cache_info;	
-	nss_cache_data *cache_data;
-	va_list ap_new;
-	int res;
+	nss_cache_info const	*cache_info;	
+	nss_cache_data	*cache_data;
+	va_list			ap_new;
+	int			res;
 	
 	cache_data = (nss_cache_data *)mdata;
 	cache_info = cache_data->info;
 	
-	if (cache_info->get_mp_ws_func() != INVALID_CACHED_MP_WRITE_SESSION)
+	if (cache_info->get_mp_ws_func() != INVALID_CACHE_MP_WRITE_SESSION)
 		return (NS_UNAVAIL);
 	
+    	_MUTEX_LOCK(&s_cache_lock);
+    	if (s_cache == INVALID_CACHE)
+		init_global_cache();
+	c_entry = find_cache_entry(s_cache, cache_info->entry_name);
+    	_MUTEX_UNLOCK(&s_cache_lock);
+
+	if (c_entry == NULL)
+	    	return (NS_UNAVAIL);
+	
 	rs = cache_info->get_mp_rs_func();
-	if (rs == INVALID_CACHED_MP_READ_SESSION) {
-		memset(&params, 0, sizeof(struct cached_connection_params));
-		params.socket_path = CACHED_SOCKET_PATH;
-		
-		rs = open_cached_mp_read_session(&params, 
-		    cache_info->entry_name);
-		if (rs == INVALID_CACHED_MP_READ_SESSION)
+	if (rs == INVALID_CACHE_MP_READ_SESSION) {
+		_MUTEX_LOCK(&s_cache_lock);
+		rs = open_cache_mp_read_session(c_entry);
+		_MUTEX_UNLOCK(&s_cache_lock);
+		if (rs == INVALID_CACHE_MP_READ_SESSION)
 			return (NS_UNAVAIL);
 		
 		cache_info->set_mp_rs_func(rs);
@@ -247,19 +323,20 @@
 	buffer = (char *)malloc(NSS_CACHE_BUFFER_INITIAL_SIZE);
 	memset(buffer, 0, NSS_CACHE_BUFFER_INITIAL_SIZE);
 	
+	_MUTEX_LOCK(&s_cache_lock);
 	do {
-		res = cached_mp_read(rs, buffer, &buffer_size);
-		if ((res == -2) && 
-		    (buffer_size < NSS_CACHE_BUFFER_SIZE_LIMIT)) {
+		res = cache_mp_read(rs, buffer, &buffer_size);
+		if ((res == -2) && (buffer_size < NSS_CACHE_BUFFER_SIZE_LIMIT)) {
 			buffer = (char *)realloc(buffer, buffer_size);
 			memset(buffer, 0, buffer_size);
 		}
 	} while (res == -2);
+	_MUTEX_UNLOCK(&s_cache_lock);
 	
 	if (res == 0) {
 		va_copy(ap_new, ap);
 		res = cache_info->unmarshal_func(buffer, buffer_size, retval, 
-	    		ap_new, cache_info->mdata);
+	    		ap_new,	cache_info->mdata);
 		va_end(ap_new);
 		
 		if (res != NS_SUCCESS) {
@@ -268,9 +345,12 @@
 		} else
 			res = 0;
 	} else {
-		close_cached_mp_read_session(rs);
-		rs = INVALID_CACHED_MP_READ_SESSION;
+	    	_MUTEX_LOCK(&s_cache_lock);
+		close_cache_mp_read_session(rs);
+	    	_MUTEX_UNLOCK(&s_cache_lock);
+		rs = INVALID_CACHE_MP_READ_SESSION;
 		cache_info->set_mp_rs_func(rs);
+		
 		return (res == -1 ? NS_RETURN : NS_UNAVAIL);
 	}
 	
@@ -281,30 +361,36 @@
 int
 nss_mp_cache_write(void *retval, void *mdata, va_list ap)
 {
-	struct cached_connection_params params;
-	cached_mp_write_session ws;
+	cache_entry	c_entry;
+    	cache_mp_write_session	ws;
 	
-	char *buffer;
-	size_t buffer_size;
+	char	*buffer;
+	size_t	buffer_size;
 
-	nss_cache_info const *cache_info;	
-	nss_cache_data *cache_data;
-	va_list ap_new;
-	int res;
+	nss_cache_info const	*cache_info;	
+	nss_cache_data	*cache_data;
+	va_list			ap_new;
+	int				res;
 	
 	cache_data = (nss_cache_data *)mdata;
 	cache_info = cache_data->info;
 	
+    	_MUTEX_LOCK(&s_cache_lock);
+    	if (s_cache == INVALID_CACHE)
+		init_global_cache();
+	c_entry = find_cache_entry(s_cache, cache_info->entry_name);
+    	_MUTEX_UNLOCK(&s_cache_lock);
+
+	if (c_entry == NULL)
+	    	return (NS_UNAVAIL);
+    
 	ws = cache_info->get_mp_ws_func();
-	if (ws == INVALID_CACHED_MP_WRITE_SESSION) {
-		memset(&params, 0, sizeof(struct cached_connection_params));
-		params.socket_path = CACHED_SOCKET_PATH;
-		
-		ws = open_cached_mp_write_session(&params, 
-			cache_info->entry_name);
-		if (ws == INVALID_CACHED_MP_WRITE_SESSION) {
+	if (ws == INVALID_CACHE_MP_WRITE_SESSION) {
+	    	_MUTEX_LOCK(&s_cache_lock);
+		ws = open_cache_mp_write_session(c_entry);
+	    	_MUTEX_UNLOCK(&s_cache_lock);
+		if (ws == INVALID_CACHE_MP_WRITE_SESSION)
 			return (NS_UNAVAIL);
-		}
 		
 		cache_info->set_mp_ws_func(ws);
 	}	
@@ -337,7 +423,9 @@
 		return (res);
 	}
 	
-	res = cached_mp_write(ws, buffer, buffer_size);
+	_MUTEX_LOCK(&s_cache_lock);
+	res = cache_mp_write(ws, buffer, buffer_size);
+	_MUTEX_UNLOCK(&s_cache_lock);
 	
 	free(buffer);	
 	return (res == 0 ? NS_SUCCESS : NS_UNAVAIL);
@@ -346,46 +434,63 @@
 int
 nss_mp_cache_write_submit(void *retval, void *mdata, va_list ap)
 {
-	cached_mp_write_session ws;
+    	cache_mp_write_session	ws;
 	
-	nss_cache_info const *cache_info;	
-	nss_cache_data *cache_data;
+	nss_cache_info const	*cache_info;	
+	nss_cache_data	*cache_data;
 	
 	cache_data = (nss_cache_data *)mdata;
 	cache_info = cache_data->info;
 	
+    	_MUTEX_LOCK(&s_cache_lock);
+    	if (s_cache == INVALID_CACHE)
+		init_global_cache();
+    	_MUTEX_UNLOCK(&s_cache_lock);      
+    
 	ws = cache_info->get_mp_ws_func();
-	if (ws != INVALID_CACHED_MP_WRITE_SESSION) {
-		close_cached_mp_write_session(ws);
-		ws = INVALID_CACHED_MP_WRITE_SESSION;
+	if (ws != INVALID_CACHE_MP_WRITE_SESSION) {
+	    	_MUTEX_LOCK(&s_cache_lock);
+		close_cache_mp_write_session(ws);
+	    	_MUTEX_UNLOCK(&s_cache_lock);
+		ws = INVALID_CACHE_MP_WRITE_SESSION;
 		cache_info->set_mp_ws_func(ws);
 	}
+
 	return (NS_UNAVAIL);
 }
 
 int
 nss_mp_cache_end(void *retval, void *mdata, va_list ap)
 {
-	cached_mp_write_session ws;
-	cached_mp_read_session rs;
+	cache_mp_write_session	ws;
+	cache_mp_read_session	rs;
 
-	nss_cache_info const *cache_info;	
-	nss_cache_data *cache_data;
+	nss_cache_info const	*cache_info;	
+	nss_cache_data	*cache_data;
 	
 	cache_data = (nss_cache_data *)mdata;
 	cache_info = cache_data->info;
 	
+        _MUTEX_LOCK(&s_cache_lock);
+    	if (s_cache == INVALID_CACHE)
+		init_global_cache();
+    	_MUTEX_UNLOCK(&s_cache_lock); 
+    
 	ws = cache_info->get_mp_ws_func();
-	if (ws != INVALID_CACHED_MP_WRITE_SESSION) {
-		abandon_cached_mp_write_session(ws);
-		ws = INVALID_CACHED_MP_WRITE_SESSION;
+	if (ws != INVALID_CACHE_MP_WRITE_SESSION) {
+	    	_MUTEX_LOCK(&s_cache_lock);
+		abandon_cache_mp_write_session(ws);
+	    	_MUTEX_UNLOCK(&s_cache_lock);
+		ws = INVALID_CACHE_MP_WRITE_SESSION;
 		cache_info->set_mp_ws_func(ws);
 	}
 	
 	rs = cache_info->get_mp_rs_func();
-	if (rs != INVALID_CACHED_MP_READ_SESSION) {
-		close_cached_mp_read_session(rs);
-		rs = INVALID_CACHED_MP_READ_SESSION;
+	if (rs != INVALID_CACHE_MP_READ_SESSION) {
+	    	_MUTEX_LOCK(&s_cache_lock);
+		close_cache_mp_read_session(rs);
+	    	_MUTEX_UNLOCK(&s_cache_lock);
+		rs = INVALID_CACHE_MP_READ_SESSION;
 		cache_info->set_mp_rs_func(rs);
 	}
 	



Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?200508312232.j7VMWRlK046203>