mp_ws_query.c revision 171795
1158115Sume/*- 2158115Sume * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru> 3158115Sume * All rights reserved. 4158115Sume * 5158115Sume * Redistribution and use in source and binary forms, with or without 6158115Sume * modification, are permitted provided that the following conditions 7158115Sume * are met: 8158115Sume * 1. Redistributions of source code must retain the above copyright 9158115Sume * notice, this list of conditions and the following disclaimer. 10158115Sume * 2. Redistributions in binary form must reproduce the above copyright 11158115Sume * notice, this list of conditions and the following disclaimer in the 12158115Sume * documentation and/or other materials provided with the distribution. 13158115Sume * 14158115Sume * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15158115Sume * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16158115Sume * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17158115Sume * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18158115Sume * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19158115Sume * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20158115Sume * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21158115Sume * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22158115Sume * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23158115Sume * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24158115Sume * SUCH DAMAGE. 25158115Sume * 26158115Sume */ 27158115Sume 28158115Sume#include <sys/cdefs.h> 29158115Sume__FBSDID("$FreeBSD: head/usr.sbin/nscd/mp_ws_query.c 171795 2007-08-09 13:06:12Z bushman $"); 30158115Sume 31158115Sume#include <sys/socket.h> 32158115Sume#include <sys/time.h> 33158115Sume#include <sys/types.h> 34158115Sume#include <sys/event.h> 35158115Sume#include <assert.h> 36158115Sume#include <errno.h> 37158115Sume#include <stdlib.h> 38158115Sume#include <string.h> 39158115Sume#include <stdio.h> 40158115Sume 41158115Sume#include "cachelib.h" 42158115Sume#include "config.h" 43158115Sume#include "debug.h" 44158115Sume#include "log.h" 45158115Sume#include "query.h" 46158115Sume#include "mp_ws_query.h" 47158115Sume#include "singletons.h" 48158115Sume 49158115Sumestatic int on_mp_write_session_abandon_notification(struct query_state *); 50158115Sumestatic int on_mp_write_session_close_notification(struct query_state *); 51158115Sumestatic void on_mp_write_session_destroy(struct query_state *); 52158115Sumestatic int on_mp_write_session_mapper(struct query_state *); 53158115Sume/* int on_mp_write_session_request_read1(struct query_state *); */ 54158115Sumestatic int on_mp_write_session_request_read2(struct query_state *); 55158115Sumestatic int on_mp_write_session_request_process(struct query_state *); 56158115Sumestatic int on_mp_write_session_response_write1(struct query_state *); 57158115Sumestatic int on_mp_write_session_write_request_read1(struct query_state *); 58158115Sumestatic int on_mp_write_session_write_request_read2(struct query_state *); 59158115Sumestatic int on_mp_write_session_write_request_process(struct query_state *); 60158115Sumestatic int on_mp_write_session_write_response_write1(struct query_state *); 61158115Sume 62158115Sume/* 63158115Sume * This function is used as the query_state's destroy_func to make the 64158115Sume * proper cleanup in case of errors. 65158115Sume */ 66158115Sumestatic void 67158115Sumeon_mp_write_session_destroy(struct query_state *qstate) 68158115Sume{ 69158115Sume 70158115Sume TRACE_IN(on_mp_write_session_destroy); 71158115Sume finalize_comm_element(&qstate->request); 72158115Sume finalize_comm_element(&qstate->response); 73158115Sume 74158115Sume if (qstate->mdata != NULL) { 75158115Sume configuration_lock_entry(qstate->config_entry, CELT_MULTIPART); 76158115Sume abandon_cache_mp_write_session( 77158115Sume (cache_mp_write_session)qstate->mdata); 78158115Sume configuration_unlock_entry(qstate->config_entry, 79158115Sume CELT_MULTIPART); 80158115Sume } 81158115Sume TRACE_OUT(on_mp_write_session_destroy); 82158115Sume} 83158115Sume 84158115Sume/* 85158115Sume * The functions below are used to process multipart write session initiation 86158115Sume * requests. 87158115Sume * - on_mp_write_session_request_read1 and on_mp_write_session_request_read2 88158115Sume * read the request itself 89158115Sume * - on_mp_write_session_request_process processes it 90158115Sume * - on_mp_write_session_response_write1 sends the response 91158115Sume */ 92158115Sumeint 93158115Sumeon_mp_write_session_request_read1(struct query_state *qstate) 94158115Sume{ 95158115Sume struct cache_mp_write_session_request *c_mp_ws_request; 96158115Sume ssize_t result; 97158115Sume 98158115Sume TRACE_IN(on_mp_write_session_request_read1); 99158115Sume if (qstate->kevent_watermark == 0) 100158115Sume qstate->kevent_watermark = sizeof(size_t); 101158115Sume else { 102158115Sume init_comm_element(&qstate->request, 103158115Sume CET_MP_WRITE_SESSION_REQUEST); 104158115Sume c_mp_ws_request = get_cache_mp_write_session_request( 105158115Sume &qstate->request); 106158115Sume 107158115Sume result = qstate->read_func(qstate, 108158115Sume &c_mp_ws_request->entry_length, sizeof(size_t)); 109158115Sume 110158115Sume if (result != sizeof(size_t)) { 111158115Sume LOG_ERR_3("on_mp_write_session_request_read1", 112158115Sume "read failed"); 113158115Sume TRACE_OUT(on_mp_write_session_request_read1); 114158115Sume return (-1); 115158115Sume } 116158115Sume 117158115Sume if (BUFSIZE_INVALID(c_mp_ws_request->entry_length)) { 118158115Sume LOG_ERR_3("on_mp_write_session_request_read1", 119158115Sume "invalid entry_length value"); 120158115Sume TRACE_OUT(on_mp_write_session_request_read1); 121158115Sume return (-1); 122158115Sume } 123158115Sume 124158115Sume c_mp_ws_request->entry = (char *)malloc( 125158115Sume c_mp_ws_request->entry_length + 1); 126158115Sume assert(c_mp_ws_request->entry != NULL); 127158115Sume memset(c_mp_ws_request->entry, 0, 128158115Sume c_mp_ws_request->entry_length + 1); 129158115Sume 130158115Sume qstate->kevent_watermark = c_mp_ws_request->entry_length; 131158115Sume qstate->process_func = on_mp_write_session_request_read2; 132158115Sume } 133158115Sume TRACE_OUT(on_mp_write_session_request_read1); 134158115Sume return (0); 135158115Sume} 136158115Sume 137158115Sumestatic int 138158115Sumeon_mp_write_session_request_read2(struct query_state *qstate) 139158115Sume{ 140158115Sume struct cache_mp_write_session_request *c_mp_ws_request; 141158115Sume ssize_t result; 142158115Sume 143158115Sume TRACE_IN(on_mp_write_session_request_read2); 144158115Sume c_mp_ws_request = get_cache_mp_write_session_request(&qstate->request); 145158115Sume 146158115Sume result = qstate->read_func(qstate, c_mp_ws_request->entry, 147158115Sume c_mp_ws_request->entry_length); 148158115Sume 149158115Sume if (result != qstate->kevent_watermark) { 150158115Sume LOG_ERR_3("on_mp_write_session_request_read2", 151158115Sume "read failed"); 152158115Sume TRACE_OUT(on_mp_write_session_request_read2); 153158115Sume return (-1); 154158115Sume } 155158115Sume 156158115Sume qstate->kevent_watermark = 0; 157158115Sume qstate->process_func = on_mp_write_session_request_process; 158158115Sume 159158115Sume TRACE_OUT(on_mp_write_session_request_read2); 160158115Sume return (0); 161158115Sume} 162158115Sume 163158115Sumestatic int 164158115Sumeon_mp_write_session_request_process(struct query_state *qstate) 165158115Sume{ 166158115Sume struct cache_mp_write_session_request *c_mp_ws_request; 167158115Sume struct cache_mp_write_session_response *c_mp_ws_response; 168158115Sume cache_mp_write_session ws; 169158115Sume cache_entry c_entry; 170158115Sume char *dec_cache_entry_name; 171158115Sume 172158115Sume TRACE_IN(on_mp_write_session_request_process); 173158115Sume init_comm_element(&qstate->response, CET_MP_WRITE_SESSION_RESPONSE); 174158115Sume c_mp_ws_response = get_cache_mp_write_session_response( 175158115Sume &qstate->response); 176158115Sume c_mp_ws_request = get_cache_mp_write_session_request(&qstate->request); 177158115Sume 178158115Sume qstate->config_entry = configuration_find_entry( 179158115Sume s_configuration, c_mp_ws_request->entry); 180158115Sume if (qstate->config_entry == NULL) { 181158115Sume c_mp_ws_response->error_code = ENOENT; 182158115Sume 183158115Sume LOG_ERR_2("write_session_request", 184158115Sume "can't find configuration entry '%s'. " 185158115Sume "aborting request", c_mp_ws_request->entry); 186158115Sume goto fin; 187158115Sume } 188158115Sume 189158115Sume if (qstate->config_entry->enabled == 0) { 190158115Sume c_mp_ws_response->error_code = EACCES; 191158115Sume 192158115Sume LOG_ERR_2("write_session_request", 193158115Sume "configuration entry '%s' is disabled", 194158115Sume c_mp_ws_request->entry); 195158115Sume goto fin; 196158115Sume } 197158115Sume 198158115Sume if (qstate->config_entry->perform_actual_lookups != 0) { 199158115Sume c_mp_ws_response->error_code = EOPNOTSUPP; 200158115Sume 201158115Sume LOG_ERR_2("write_session_request", 202158115Sume "entry '%s' performs lookups by itself: " 203158115Sume "can't write to it", c_mp_ws_request->entry); 204158115Sume goto fin; 205158115Sume } else { 206171795Sbushman#ifdef NS_NSCD_EID_CHECKING 207158115Sume if (check_query_eids(qstate) != 0) { 208158115Sume c_mp_ws_response->error_code = EPERM; 209158115Sume goto fin; 210158115Sume } 211158115Sume#endif 212158115Sume } 213158115Sume 214158115Sume /* 215158115Sume * All multipart entries are separated by their name decorations. 216158115Sume * For one configuration entry there will be a lot of multipart 217158115Sume * cache entries - each with its own decorated name. 218158115Sume */ 219158115Sume asprintf(&dec_cache_entry_name, "%s%s", qstate->eid_str, 220158115Sume qstate->config_entry->mp_cache_params.entry_name); 221158115Sume assert(dec_cache_entry_name != NULL); 222158115Sume 223158115Sume configuration_lock_rdlock(s_configuration); 224158115Sume c_entry = find_cache_entry(s_cache, 225158115Sume dec_cache_entry_name); 226158115Sume configuration_unlock(s_configuration); 227158115Sume 228158115Sume if (c_entry == INVALID_CACHE_ENTRY) 229158115Sume c_entry = register_new_mp_cache_entry(qstate, 230158115Sume dec_cache_entry_name); 231158115Sume 232158115Sume free(dec_cache_entry_name); 233158115Sume 234158115Sume assert(c_entry != NULL); 235158115Sume configuration_lock_entry(qstate->config_entry, CELT_MULTIPART); 236158115Sume ws = open_cache_mp_write_session(c_entry); 237158115Sume if (ws == INVALID_CACHE_MP_WRITE_SESSION) 238158115Sume c_mp_ws_response->error_code = -1; 239158115Sume else { 240158115Sume qstate->mdata = ws; 241158115Sume qstate->destroy_func = on_mp_write_session_destroy; 242158115Sume 243158115Sume if ((qstate->config_entry->mp_query_timeout.tv_sec != 0) || 244158115Sume (qstate->config_entry->mp_query_timeout.tv_usec != 0)) 245158115Sume memcpy(&qstate->timeout, 246158115Sume &qstate->config_entry->mp_query_timeout, 247158115Sume sizeof(struct timeval)); 248158115Sume } 249158115Sume configuration_unlock_entry(qstate->config_entry, CELT_MULTIPART); 250158115Sume 251158115Sumefin: 252158115Sume qstate->process_func = on_mp_write_session_response_write1; 253158115Sume qstate->kevent_watermark = sizeof(int); 254158115Sume qstate->kevent_filter = EVFILT_WRITE; 255158115Sume 256158115Sume TRACE_OUT(on_mp_write_session_request_process); 257158115Sume return (0); 258158115Sume} 259158115Sume 260158115Sumestatic int 261158115Sumeon_mp_write_session_response_write1(struct query_state *qstate) 262158115Sume{ 263158115Sume struct cache_mp_write_session_response *c_mp_ws_response; 264158115Sume ssize_t result; 265158115Sume 266158115Sume TRACE_IN(on_mp_write_session_response_write1); 267158115Sume c_mp_ws_response = get_cache_mp_write_session_response( 268158115Sume &qstate->response); 269158115Sume result = qstate->write_func(qstate, &c_mp_ws_response->error_code, 270158115Sume sizeof(int)); 271158115Sume if (result != sizeof(int)) { 272158115Sume LOG_ERR_3("on_mp_write_session_response_write1", 273158115Sume "write failed"); 274158115Sume TRACE_OUT(on_mp_write_session_response_write1); 275158115Sume return (-1); 276158115Sume } 277158115Sume 278158115Sume if (c_mp_ws_response->error_code == 0) { 279158115Sume qstate->kevent_watermark = sizeof(int); 280158115Sume qstate->process_func = on_mp_write_session_mapper; 281158115Sume qstate->kevent_filter = EVFILT_READ; 282158115Sume } else { 283158115Sume qstate->kevent_watermark = 0; 284158115Sume qstate->process_func = NULL; 285158115Sume } 286158115Sume TRACE_OUT(on_mp_write_session_response_write1); 287158115Sume return (0); 288158115Sume} 289158115Sume 290158115Sume/* 291158115Sume * Mapper function is used to avoid multiple connections for each session 292158115Sume * write or read requests. After processing the request, it does not close 293158115Sume * the connection, but waits for the next request. 294158115Sume */ 295158115Sumestatic int 296158115Sumeon_mp_write_session_mapper(struct query_state *qstate) 297158115Sume{ 298158115Sume ssize_t result; 299158115Sume int elem_type; 300158115Sume 301158115Sume TRACE_IN(on_mp_write_session_mapper); 302158115Sume if (qstate->kevent_watermark == 0) { 303158115Sume qstate->kevent_watermark = sizeof(int); 304158115Sume } else { 305158115Sume result = qstate->read_func(qstate, &elem_type, sizeof(int)); 306158115Sume if (result != sizeof(int)) { 307158115Sume LOG_ERR_3("on_mp_write_session_mapper", 308158115Sume "read failed"); 309158115Sume TRACE_OUT(on_mp_write_session_mapper); 310158115Sume return (-1); 311158115Sume } 312158115Sume 313158115Sume switch (elem_type) { 314158115Sume case CET_MP_WRITE_SESSION_WRITE_REQUEST: 315158115Sume qstate->kevent_watermark = sizeof(size_t); 316158115Sume qstate->process_func = 317158115Sume on_mp_write_session_write_request_read1; 318158115Sume break; 319158115Sume case CET_MP_WRITE_SESSION_ABANDON_NOTIFICATION: 320158115Sume qstate->kevent_watermark = 0; 321158115Sume qstate->process_func = 322158115Sume on_mp_write_session_abandon_notification; 323158115Sume break; 324158115Sume case CET_MP_WRITE_SESSION_CLOSE_NOTIFICATION: 325158115Sume qstate->kevent_watermark = 0; 326158115Sume qstate->process_func = 327158115Sume on_mp_write_session_close_notification; 328158115Sume break; 329158115Sume default: 330158115Sume qstate->kevent_watermark = 0; 331158115Sume qstate->process_func = NULL; 332158115Sume LOG_ERR_2("on_mp_write_session_mapper", 333158115Sume "unknown element type"); 334158115Sume TRACE_OUT(on_mp_write_session_mapper); 335158115Sume return (-1); 336158115Sume } 337158115Sume } 338158115Sume TRACE_OUT(on_mp_write_session_mapper); 339158115Sume return (0); 340158115Sume} 341158115Sume 342158115Sume/* 343158115Sume * The functions below are used to process multipart write sessions write 344158115Sume * requests. 345158115Sume * - on_mp_write_session_write_request_read1 and 346158115Sume * on_mp_write_session_write_request_read2 read the request itself 347158115Sume * - on_mp_write_session_write_request_process processes it 348158115Sume * - on_mp_write_session_write_response_write1 sends the response 349158115Sume */ 350158115Sumestatic int 351158115Sumeon_mp_write_session_write_request_read1(struct query_state *qstate) 352158115Sume{ 353158115Sume struct cache_mp_write_session_write_request *write_request; 354158115Sume ssize_t result; 355158115Sume 356158115Sume TRACE_IN(on_mp_write_session_write_request_read1); 357158115Sume init_comm_element(&qstate->request, 358158115Sume CET_MP_WRITE_SESSION_WRITE_REQUEST); 359158115Sume write_request = get_cache_mp_write_session_write_request( 360158115Sume &qstate->request); 361158115Sume 362158115Sume result = qstate->read_func(qstate, &write_request->data_size, 363158115Sume sizeof(size_t)); 364158115Sume 365158115Sume if (result != sizeof(size_t)) { 366158115Sume LOG_ERR_3("on_mp_write_session_write_request_read1", 367158115Sume "read failed"); 368158115Sume TRACE_OUT(on_mp_write_session_write_request_read1); 369158115Sume return (-1); 370158115Sume } 371158115Sume 372158115Sume if (BUFSIZE_INVALID(write_request->data_size)) { 373158115Sume LOG_ERR_3("on_mp_write_session_write_request_read1", 374158115Sume "invalid data_size value"); 375158115Sume TRACE_OUT(on_mp_write_session_write_request_read1); 376158115Sume return (-1); 377158115Sume } 378158115Sume 379158115Sume write_request->data = (char *)malloc(write_request->data_size); 380158115Sume assert(write_request->data != NULL); 381158115Sume memset(write_request->data, 0, write_request->data_size); 382158115Sume 383158115Sume qstate->kevent_watermark = write_request->data_size; 384158115Sume qstate->process_func = on_mp_write_session_write_request_read2; 385158115Sume TRACE_OUT(on_mp_write_session_write_request_read1); 386158115Sume return (0); 387158115Sume} 388158115Sume 389158115Sumestatic int 390158115Sumeon_mp_write_session_write_request_read2(struct query_state *qstate) 391158115Sume{ 392158115Sume struct cache_mp_write_session_write_request *write_request; 393158115Sume ssize_t result; 394158115Sume 395158115Sume TRACE_IN(on_mp_write_session_write_request_read2); 396158115Sume write_request = get_cache_mp_write_session_write_request( 397158115Sume &qstate->request); 398158115Sume 399158115Sume result = qstate->read_func(qstate, write_request->data, 400158115Sume write_request->data_size); 401158115Sume 402158115Sume if (result != qstate->kevent_watermark) { 403158115Sume LOG_ERR_3("on_mp_write_session_write_request_read2", 404158115Sume "read failed"); 405158115Sume TRACE_OUT(on_mp_write_session_write_request_read2); 406158115Sume return (-1); 407158115Sume } 408158115Sume 409158115Sume qstate->kevent_watermark = 0; 410158115Sume qstate->process_func = on_mp_write_session_write_request_process; 411158115Sume TRACE_OUT(on_mp_write_session_write_request_read2); 412158115Sume return (0); 413158115Sume} 414158115Sume 415158115Sumestatic int 416158115Sumeon_mp_write_session_write_request_process(struct query_state *qstate) 417158115Sume{ 418158115Sume struct cache_mp_write_session_write_request *write_request; 419158115Sume struct cache_mp_write_session_write_response *write_response; 420158115Sume 421158115Sume TRACE_IN(on_mp_write_session_write_request_process); 422158115Sume init_comm_element(&qstate->response, 423158115Sume CET_MP_WRITE_SESSION_WRITE_RESPONSE); 424158115Sume write_response = get_cache_mp_write_session_write_response( 425158115Sume &qstate->response); 426158115Sume write_request = get_cache_mp_write_session_write_request( 427158115Sume &qstate->request); 428158115Sume 429158115Sume configuration_lock_entry(qstate->config_entry, CELT_MULTIPART); 430158115Sume write_response->error_code = cache_mp_write( 431158115Sume (cache_mp_write_session)qstate->mdata, 432158115Sume write_request->data, 433158115Sume write_request->data_size); 434158115Sume configuration_unlock_entry(qstate->config_entry, CELT_MULTIPART); 435158115Sume 436158115Sume qstate->kevent_watermark = sizeof(int); 437158115Sume qstate->process_func = on_mp_write_session_write_response_write1; 438158115Sume qstate->kevent_filter = EVFILT_WRITE; 439158115Sume 440158115Sume TRACE_OUT(on_mp_write_session_write_request_process); 441158115Sume return (0); 442158115Sume} 443158115Sume 444158115Sumestatic int 445158115Sumeon_mp_write_session_write_response_write1(struct query_state *qstate) 446158115Sume{ 447158115Sume struct cache_mp_write_session_write_response *write_response; 448158115Sume ssize_t result; 449158115Sume 450158115Sume TRACE_IN(on_mp_write_session_write_response_write1); 451158115Sume write_response = get_cache_mp_write_session_write_response( 452158115Sume &qstate->response); 453158115Sume result = qstate->write_func(qstate, &write_response->error_code, 454158115Sume sizeof(int)); 455158115Sume if (result != sizeof(int)) { 456158115Sume LOG_ERR_3("on_mp_write_session_write_response_write1", 457158115Sume "write failed"); 458158115Sume TRACE_OUT(on_mp_write_session_write_response_write1); 459158115Sume return (-1); 460158115Sume } 461158115Sume 462158115Sume if (write_response->error_code == 0) { 463158115Sume finalize_comm_element(&qstate->request); 464158115Sume finalize_comm_element(&qstate->response); 465158115Sume 466158115Sume qstate->kevent_watermark = sizeof(int); 467158115Sume qstate->process_func = on_mp_write_session_mapper; 468158115Sume qstate->kevent_filter = EVFILT_READ; 469158115Sume } else { 470158115Sume qstate->kevent_watermark = 0; 471158115Sume qstate->process_func = 0; 472158115Sume } 473158115Sume 474158115Sume TRACE_OUT(on_mp_write_session_write_response_write1); 475158115Sume return (0); 476158115Sume} 477158115Sume 478158115Sume/* 479158115Sume * Handles abandon notifications. Destroys the session by calling the 480158115Sume * abandon_cache_mp_write_session. 481158115Sume */ 482158115Sumestatic int 483158115Sumeon_mp_write_session_abandon_notification(struct query_state *qstate) 484158115Sume{ 485158115Sume TRACE_IN(on_mp_write_session_abandon_notification); 486158115Sume configuration_lock_entry(qstate->config_entry, CELT_MULTIPART); 487158115Sume abandon_cache_mp_write_session((cache_mp_write_session)qstate->mdata); 488158115Sume configuration_unlock_entry(qstate->config_entry, CELT_MULTIPART); 489158115Sume qstate->mdata = INVALID_CACHE_MP_WRITE_SESSION; 490158115Sume 491158115Sume qstate->kevent_watermark = 0; 492158115Sume qstate->process_func = NULL; 493158115Sume TRACE_OUT(on_mp_write_session_abandon_notification); 494158115Sume return (0); 495158115Sume} 496158115Sume 497158115Sume/* 498158115Sume * Handles close notifications. Commits the session by calling 499158115Sume * the close_cache_mp_write_session. 500158115Sume */ 501158115Sumestatic int 502158115Sumeon_mp_write_session_close_notification(struct query_state *qstate) 503158115Sume{ 504158115Sume TRACE_IN(on_mp_write_session_close_notification); 505158115Sume configuration_lock_entry(qstate->config_entry, CELT_MULTIPART); 506158115Sume close_cache_mp_write_session((cache_mp_write_session)qstate->mdata); 507158115Sume configuration_unlock_entry(qstate->config_entry, CELT_MULTIPART); 508158115Sume qstate->mdata = INVALID_CACHE_MP_WRITE_SESSION; 509158115Sume 510158115Sume qstate->kevent_watermark = 0; 511158115Sume qstate->process_func = NULL; 512158115Sume TRACE_OUT(on_mp_write_session_close_notification); 513158115Sume return (0); 514158115Sume} 515158115Sume 516158115Sumecache_entry register_new_mp_cache_entry(struct query_state *qstate, 517158115Sume const char *dec_cache_entry_name) 518158115Sume{ 519158115Sume cache_entry c_entry; 520158115Sume char *en_bkp; 521158115Sume 522158115Sume TRACE_IN(register_new_mp_cache_entry); 523158115Sume c_entry = INVALID_CACHE_ENTRY; 524158115Sume configuration_lock_entry(qstate->config_entry, CELT_MULTIPART); 525158115Sume 526158115Sume configuration_lock_wrlock(s_configuration); 527158115Sume en_bkp = qstate->config_entry->mp_cache_params.entry_name; 528158115Sume qstate->config_entry->mp_cache_params.entry_name = 529158115Sume (char *)dec_cache_entry_name; 530158115Sume register_cache_entry(s_cache, (struct cache_entry_params *) 531158115Sume &qstate->config_entry->mp_cache_params); 532158115Sume qstate->config_entry->mp_cache_params.entry_name = en_bkp; 533158115Sume configuration_unlock(s_configuration); 534158115Sume 535158115Sume configuration_lock_rdlock(s_configuration); 536158115Sume c_entry = find_cache_entry(s_cache, 537158115Sume dec_cache_entry_name); 538158115Sume configuration_unlock(s_configuration); 539158115Sume 540158115Sume configuration_entry_add_mp_cache_entry(qstate->config_entry, 541158115Sume c_entry); 542158115Sume 543158115Sume configuration_unlock_entry(qstate->config_entry, 544158115Sume CELT_MULTIPART); 545158115Sume 546158115Sume TRACE_OUT(register_new_mp_cache_entry); 547158115Sume return (c_entry); 548158115Sume} 549