From owner-p4-projects@FreeBSD.ORG Wed Aug 31 22:32:29 2005 Return-Path: X-Original-To: p4-projects@freebsd.org Delivered-To: p4-projects@freebsd.org Received: by hub.freebsd.org (Postfix, from userid 32767) id C71E916A421; Wed, 31 Aug 2005 22:32:28 +0000 (GMT) X-Original-To: perforce@freebsd.org Delivered-To: perforce@freebsd.org Received: from mx1.FreeBSD.org (mx1.freebsd.org [216.136.204.125]) by hub.freebsd.org (Postfix) with ESMTP id 7251216A41F for ; Wed, 31 Aug 2005 22:32:28 +0000 (GMT) (envelope-from soc-bushman@freebsd.org) Received: from repoman.freebsd.org (repoman.freebsd.org [216.136.204.115]) by mx1.FreeBSD.org (Postfix) with ESMTP id 258E543D45 for ; Wed, 31 Aug 2005 22:32:28 +0000 (GMT) (envelope-from soc-bushman@freebsd.org) Received: from repoman.freebsd.org (localhost [127.0.0.1]) by repoman.freebsd.org (8.13.1/8.13.1) with ESMTP id j7VMWSSG046206 for ; Wed, 31 Aug 2005 22:32:28 GMT (envelope-from soc-bushman@freebsd.org) Received: (from perforce@localhost) by repoman.freebsd.org (8.13.1/8.13.1/Submit) id j7VMWRlK046203 for perforce@freebsd.org; Wed, 31 Aug 2005 22:32:27 GMT (envelope-from soc-bushman@freebsd.org) Date: Wed, 31 Aug 2005 22:32:27 GMT Message-Id: <200508312232.j7VMWRlK046203@repoman.freebsd.org> X-Authentication-Warning: repoman.freebsd.org: perforce set sender to soc-bushman@freebsd.org using -f From: soc-bushman To: Perforce Change Reviews Cc: Subject: PERFORCE change 82946 for review X-BeenThere: p4-projects@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: p4 projects tree changes List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Wed, 31 Aug 2005 22:32:29 -0000 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 + 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 +#include "namespace.h" +#include "nsswitch.h" +#include #include #include +#include "un-namespace.h" -#include +#include #include +#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(¶ms, 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 *)¶ms); +} + +static void +register_global_ce_mp_entry(const char *name) +{ + struct mp_cache_entry_params params; + + memset(¶ms, 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 *)¶ms); +} + +static void +init_global_cache() +{ + struct cache_params params; + + memset(¶ms, 0, sizeof(struct cache_params)); + params.get_time_func = get_time_func; + s_cache = init_cache(¶ms); + + 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(¶ms, 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(¶ms); - 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(¶ms, 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(¶ms); - 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(¶ms, 0, sizeof(struct cached_connection_params)); - params.socket_path = CACHED_SOCKET_PATH; - - rs = open_cached_mp_read_session(¶ms, - 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(¶ms, 0, sizeof(struct cached_connection_params)); - params.socket_path = CACHED_SOCKET_PATH; - - ws = open_cached_mp_write_session(¶ms, - 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); }