hcq/MaxScale
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Changes to try to eliminate setting dcb->session to NULL with risk of crashing system.

Browse Source
This commit is contained in:
counterpoint
2015-08-24 12:12:43 +01:00
parent 5e2e2585ad
commit 37ac158791
7 changed files with 182 additions and 194 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
server/core/poll.c
View File

@ -26,7 +26,6 @@
#include <poll.h>
#include <dcb.h>
#include <atomic.h>
#include <session.h>
#include <gwbitmask.h>
#include <skygw_utils.h>
#include <log_manager.h>
@ -909,14 +908,6 @@ unsigned long qtime;
{
if (dcb->state == DCB_STATE_LISTENING)
{
if (NULL == dcb->session)
{
dcb->session = (SESSION *)session_alloc(dcb->service, dcb);
if (dcb->session)
{
dcb->session->state = SESSION_STATE_LISTENER;
}
}
LOGIF(LD, (skygw_log_write(
LOGFILE_DEBUG,
"%lu [poll_waitevents] "

20
server/core/service.c
View File

@ -354,7 +354,6 @@ GWPROTOCOL *funcs;
goto retblock;
}
memcpy(&(port->listener->func), funcs, sizeof(GWPROTOCOL));
port->listener->session = NULL;
if (port->address)
sprintf(config_bind, "%s:%d", port->address, port->port);
@ -363,8 +362,25 @@ GWPROTOCOL *funcs;
if (port->listener->func.listen(port->listener, config_bind))
{
port->listener->session = session_alloc(service, port->listener);
if (port->listener->session != NULL)
{
port->listener->session->state = SESSION_STATE_LISTENER;
listeners += 1;
/* If lazy session creation fails, how does listeners get decremented? */
}
else
{
LOGIF(LE, (skygw_log_write_flush(
LOGFILE_ERROR,
"Error : Failed to create session to service %s.",
service->name)));
users_free(service->users);
dcb_close(port->listener);
port->listener = NULL;
goto retblock;
}
}
else
{

160
server/core/session.c
View File

@ -58,6 +58,7 @@ static SESSION *allSessions = NULL;
static int session_setup_filters(SESSION *session);
static void session_simple_free(SESSION *session, DCB *dcb);
/**
* Allocate a new session for a new client of the specified service.
@ -76,8 +77,7 @@ session_alloc(SERVICE *service, DCB *client_dcb)
SESSION *session;
session = (SESSION *)calloc(1, sizeof(SESSION));
ss_info_dassert(session != NULL,
"Allocating memory for session failed.");
ss_info_dassert(session != NULL, "Allocating memory for session failed.");
if (session == NULL)
{
@ -87,28 +87,15 @@ session_alloc(SERVICE *service, DCB *client_dcb)
"session object due error %d, %s.",
errno,
strerror(errno))));
if (client_dcb->data && !DCB_IS_CLONE(client_dcb))
{
void *clientdata = client_dcb->data;
client_dcb->data = NULL;
free(clientdata);
}
goto return_session;
session_simple_free(session, client_dcb);
return NULL;
}
#if defined(SS_DEBUG)
session->ses_chk_top = CHK_NUM_SESSION;
session->ses_chk_tail = CHK_NUM_SESSION;
#endif
if (DCB_IS_CLONE(client_dcb))
{
session->ses_is_child = true;
}
session->ses_is_child = (bool) DCB_IS_CLONE(client_dcb);
spinlock_init(&session->ses_lock);
/*<
* Prevent backend threads from accessing before session is completely
* initialized.
*/
spinlock_acquire(&session->ses_lock);
session->service = service;
session->client = client_dcb;
session->n_filters = 0;
@ -123,7 +110,6 @@ session_alloc(SERVICE *service, DCB *client_dcb)
* point.
*/
session->data = client_dcb->data;
client_dcb->session = session;
session->refcount = 1;
/*<
* This indicates that session is ready to be shared with backend
@ -131,9 +117,6 @@ session_alloc(SERVICE *service, DCB *client_dcb)
*/
session->state = SESSION_STATE_READY;
/*< Release session lock */
spinlock_release(&session->ses_lock);
/*
* Only create a router session if we are not the listening
* DCB or an internal DCB. Creating a router session may create a connection to a
@ -147,28 +130,20 @@ session_alloc(SERVICE *service, DCB *client_dcb)
if (client_dcb->state != DCB_STATE_LISTENING &&
client_dcb->dcb_role != DCB_ROLE_INTERNAL)
{
session->router_session =
service->router->newSession(service->router_instance, session);
session->router_session = service->router->newSession(service->router_instance, session);
if (session->router_session == NULL)
{
/**
* Inform other threads that session is closing.
*/
session->state = SESSION_STATE_STOPPING;
/*<
* Decrease refcount, set dcb's session pointer NULL
* and set session pointer to NULL.
*/
session->client = NULL;
session_free(session);
client_dcb->session = NULL;
session = NULL;
session_simple_free(session, client_dcb);
LOGIF(LE, (skygw_log_write_flush(
LOGFILE_ERROR,
"Error : Failed to create %s session.",
"%lu [%s] Error : Failed to create %s session because router"
"could not establish a new router session, see earlier error.",
pthread_self(),
__func__,
service->name)));
goto return_session;
return NULL;
}
/*
* Pending filter chain being setup set the head of the chain to
@ -192,49 +167,20 @@ session_alloc(SERVICE *service, DCB *client_dcb)
{
if (!session_setup_filters(session))
{
/**
* Inform other threads that session is closing.
*/
session->state = SESSION_STATE_STOPPING;
/*<
* Decrease refcount, set dcb's session pointer NULL
* and set session pointer to NULL.
*/
session->client = NULL;
session_free(session);
client_dcb->session = NULL;
session = NULL;
session_simple_free(session, client_dcb);
LOGIF(LE, (skygw_log_write(
LOGFILE_ERROR,
"Error : Setting up filters failed. "
"Terminating session %s.",
service->name)));
goto return_session;
return NULL;
}
}
}
spinlock_acquire(&session->ses_lock);
if (session->state != SESSION_STATE_READY)
{
spinlock_release(&session->ses_lock);
session->client = NULL;
session_free(session);
client_dcb->session = NULL;
session = NULL;
LOGIF(LE, (skygw_log_write_flush(
LOGFILE_ERROR,
"Error : Failed to create %s session.",
service->name)));
spinlock_release(&session_spin);
}
else
{
session->state = SESSION_STATE_ROUTER_READY;
spinlock_release(&session->ses_lock);
spinlock_acquire(&session_spin);
/** Assign a session id and increase */
/** Assign a session id and increase, insert session into list */
session->ses_id = ++session_id;
session->next = allSessions;
allSessions = session;
@ -261,8 +207,8 @@ session_alloc(SERVICE *service, DCB *client_dcb)
atomic_add(&service->stats.n_sessions, 1);
atomic_add(&service->stats.n_current, 1);
CHK_SESSION(session);
}
return_session:
client_dcb->session = session;
return session;
}
@ -360,30 +306,57 @@ int session_unlink_dcb(
return nlink;
}
/**
* Deallocate the specified session, minimal actions during session_alloc
*
* @param session The session to deallocate
*/
static void
session_simple_free(SESSION *session, DCB *dcb)
{
/* Does this possibly need a lock? */
if (dcb->data && !DCB_IS_CLONE(dcb))
{
void * clientdata = dcb->data;
dcb->data = NULL;
free(clientdata);
}
if (session)
{
if (session && session->router_session)
{
session->service->router->freeSession(
session->service->router_instance,
session->router_session);
}
session->state = SESSION_STATE_STOPPING;
}
free(session);
}
/**
* Deallocate the specified session
*
* @param session The session to deallocate
*/
bool session_free(
SESSION *session)
bool
session_free(SESSION *session)
{
bool succp = false;
SESSION *ptr;
int nlink;
int i;
CHK_SESSION(session);
/*<
/*
* Remove one reference. If there are no references left,
* free session.
*/
nlink = session_unlink_dcb(session, NULL);
if (nlink != 0) {
if (atomic_add(&session->refcount, -1) - 1)
{
/* Must be one or more references left */
ss_dassert(nlink > 0);
goto return_succp;
return false;
}
session->state = SESSION_STATE_TO_BE_FREED;
/* First of all remove from the linked list */
spinlock_acquire(&session_spin);
@ -393,13 +366,16 @@ bool session_free(
}
else
{
ptr = allSessions;
while (ptr && ptr->next != session)
SESSION *chksession;
chksession = allSessions;
while (chksession && chksession->next != session)
{
ptr = ptr->next;
chksession = chksession->next;
}
if (chksession)
{
chksession->next = session->next;
}
if (ptr)
ptr->next = session->next;
}
spinlock_release(&session_spin);
atomic_add(&session->service->stats.n_current, -1);
@ -416,6 +392,7 @@ bool session_free(
}
if (session->n_filters)
{
int i;
for (i = 0; i < session->n_filters; i++)
{
if (session->filters[i].filter)
@ -453,10 +430,7 @@ bool session_free(
}
free(session);
}
succp = true;
return_succp :
return succp;
return true;
}
/**

6
server/modules/protocol/httpd.c
View File

@ -351,7 +351,8 @@ int n_connect = 0;
memcpy(&client->func, &MyObject, sizeof(GWPROTOCOL));
/* we don't need the session */
client->session = NULL;
/* But not clear that we have one! */
/* client->session = NULL; */
/* create the session data for HTTPD */
client_data = (HTTPD_session *)calloc(1, sizeof(HTTPD_session));
@ -360,9 +361,10 @@ int n_connect = 0;
client->session =
session_alloc(dcb->session->service, client);
if (poll_add_dcb(client) == -1)
if (NULL == client->session || poll_add_dcb(client) == -1)
{
close(so);
dcb_close(client);
return n_connect;
}
n_connect++;

2
server/modules/protocol/maxscaled.c
View File

@ -291,7 +291,7 @@ int n_connect = 0;
client_dcb->session =
session_alloc(dcb->session->service, client_dcb);
if (poll_add_dcb(client_dcb))
if (NULL == client_dcb->session || poll_add_dcb(client_dcb))
{
dcb_close(dcb);
return n_connect;

5
server/modules/protocol/telnetd.c
View File

@ -311,6 +311,11 @@ int n_connect = 0;
memcpy(&client_dcb->func, &MyObject, sizeof(GWPROTOCOL));
client_dcb->session =
session_alloc(dcb->session->service, client_dcb);
if (NULL == client_dcb->session)
{
dcb_close(client_dcb);
return n_connect;
}
telnetd_pr = (TELNETD *)malloc(sizeof(TELNETD));
client_dcb->protocol = (void *)telnetd_pr;

2
server/modules/routing/readwritesplit/readwritesplit.c
View File

@ -1684,7 +1684,7 @@ static skygw_query_type_t is_read_tmp_table(
{
skygw_log_write(LE,"[%s] Error: Master server reference is NULL.",
__FUNCTION__);
return;
return type;
}
rses_prop_tmp = router_cli_ses->rses_properties[RSES_PROP_TYPE_TMPTABLES];