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

All changes 2.0.0...develop

Browse Source 
973b983 Merge branch 'release-2.0.0' into develop
255dd23 Make spinlock functions take const argument
6e23bab Fix bitmask reallocation
338c189 Rename and clean up slavelag filter
3ea8f28 Fix possible NULL pointer dereference
bfe6738 MXS-830: Add module information to logged messages
1fad962 Fix strncat usage
d38997a Adjust log throttling policy
0be4e4b Add hashtable_item_strcasecmp
726100e Take hashtable convenience functions into use
5e7744a Fix typo in maxadmin.md
c5778c8 Merge branch 'release-2.0.0' into develop
b5762af Move from tmpnam to mkstemp
d6f2c71 Add convenience functions to hashtable
359058a MXS-825: Add support for --execdir
636347c Enable runtime reconfiguration of log throttling
ef9fba9 Improve log throttling documentation
aef917a Implement log throttling
e3a5349 Remove shardrouter.c
8051e80 Remove custom qc_sqlite allocation functions
fd34d60 Initial implementation of the learning firewall
a8752a8 Removed "filestem option" from example
1ef2519 Removed "filestem option" from example
0815cc8 Cleanup spinlock.h
ab4dc99 Clean up hashtable.h
ef2c078 Add prototypes for hashtable copy and free functions
fb5cfaf Add 'log_throttling' configuration entry
300d823 Add proper prototypes for hashtable hash and cmp functions
1c649aa qc_mysqlembedded: Include skygw_...h without path.
d276160 Add missing RPM scripts
e70e644 Fix HTTPAuth installation
1b2b389 Combine utils into the server directory
3ff9913 Add missing utils headers to devel package
407efb2 Fix minor packaging problems
99aa6ad Split MaxScale into core, experimental and devel packages
1290386 Merge branch 'develop' of ssh://github.com/mariadb-corporation/maxscale-new into develop
e59f148 Make scripts POSIX sh compatible
7319266 Fixed SHOW SLAVE STATUS in bonlog router
f8d760a Update Binlogrouter.md
0a904ed Update Replication-Proxy-Binlog-Router-Tutorial.md
75d4202 Update Replication-Proxy-Binlog-Router-Tutorial.md
b8651fc Add missing newline in listmanager.h
c7ad047 Add note about user data caches to release notes
70ccc2b Merge branch 'release-2.0.0' into develop
575d1b6 Mistake - dummy session needs list markers set.
8364508 Merge branch 'develop' into binlog_server_semisync
868b902 Update MaxScale limitations
2c8b327 Store listener caches in separate directories
6e183ec Create unique user data caches for each listeners
f643685 Don't free orphaned tee filter sessions
4179afa Allow binlogrouter to be used without a listener
7ad79af Add function for freeing a listener
677a0a2 Move authentication data from services to listeners
4f12af7 Merge remote-tracking branch 'origin/MXS-677' into develop
1419b81 Semi-Sync support to binlog server: code review updtate
0ea0f01 Semi-Sync support to binlog server: added missing routine
4aad909 Semi-Sync support to binlog server
b824e1e Add authenticator support to httpd.c
705a688 Change tabs to spaces
d0c419e Change method of adding list fields to e.g. DCB
25504fc Document the changed routing priority of hints
41666d1 Remove use_ssl_if_enabled global option
a3584e9 Make routing hints have highest priority
34a1d24 Updated document with new binlog router option
01eedc5 Updated documentation with SSL usage
8a4c0f6 Update Replication-Proxy-Binlog-Router-Tutorial.md
4e374aa Update Replication-Proxy-Binlog-Router-Tutorial.md
f3f3c57 Update Replication-Proxy-Binlog-Router-Tutorial.md
617b79f Binlog Server: error messages typo fix
fa8dfae Binlog Server: error messages review
1b8819c Fix freeing of schemarouter session memory
07f49e1 MXS-788: new code review fix
1fd3b09 MXS-788: show services now displays SSL info
6ca2584 MXS-788 code review fix
ae6a7d0 MXS-788 code review
43d3474 Master server SSL connection
90b2377 Use correct variable in listmanager pre-allocation
9a5b238 Fix listmanager pre-allocation
9c78625 Fix a memory leak when backend authentication fails
e59a966 Fix hang in list_find_free
ff30223 Fix freeing of shared data in schemarouter
fc8f9d3 Add missing include in luafilter
ecf7f53 Add missing NULL value to filter parameter array
636d849 Update memory allocation approach
f0d1d38 Add new allocation functions
97d00a0 Fix writing of uninitialized data to logs
e72c9b2 Merge branch 'release-2.0.0' into develop
cf2b712 Merge branch 'release-2.0.0' into develop
8917c5c Change the logic behind valid list entry checks
c10deff Improve documentation about version_string
f59f1f7 Merge branch 'develop' of ssh://github.com/mariadb-corporation/maxscale-new into develop
c88edb3 Backend authentication failure improvement
abd5bee Revert "Backend authentication failure improvement"
5bb3107 Backend authentication failure improvement
b7f434a Add new allocation functions
3f022fa Fix stupid mistake
99c4317 Merge remote-tracking branch 'origin/MXS-677' into develop
3c1ded6 Added connection/authentication failure error reporting in SHOW SLAVE STATUS
0a60f7b Tidy up and deal with review points.
ba103ff blr_slave.c: Update strncpy usage
467331e blr_master.c: Strncpy usage updates
d2b7c0c Merge remote-tracking branch 'origin/develop-nullauth-merge' into develop
5a8c1d0 qc: Measure execution time at the right place.
bccdb93 Merge branch 'NullAuthDeny' into develop
2e6511c Add 5.5.5 prefix to all version strings that lack it
314655a Improve DCB and session initialization and list handling
e1c43f0 MXS-655: Make MaxScale logging logrotate(8) compatible
ce36afd MXS-626: Don't log a header unless maxlog enabled
dcd47a7 blr_file.c: Replace uses of strncpy
6b8f576 bls_slave.c: Replace strncpy with memcpy
68a0039 Add list preallocation, tidy up, simplify init.
cb37d1b Fix copyright etc headers.
11a400d Tidy; comment; fix bad copies and mistakes.
7e36ec4 Add list manager files.
c4794e3 Initial code for list manager.
1b42e25 Merge remote-tracking branch 'origin/MXS-765' into develop
d50f617 Fix problems, extend tests, respond to review.
dcb4a91 Filter test folder removed
0b60dbe Add a couple of comments.
83cdba0 Fix overwriting problem.
ba5d353 Fix overwriting problem.
53671cb Small fixes in response to review.
173d049 blr.c: Review strncpy usage
4ff6ef2 binlog_common.c: Replace strncpy with memcpy
f238e03 maxbinlogcheck.s: Replace strncpy
9807f8d harness: Replace unnecessary use of strncpy
8c7fe6a avro: Modify strncpy usage
9b8008e Small improvements.
b7f784f Fix mistakes in testqueuemanager.c
cc26962 Restore missing poll.c code; add testqueuemanager.c.
2e91806 Format the filter harness
22059e6 Initial implementation connection queueing.
c604dc2 readwritesplit.c: Improve COM_INIT_DB handling
454d920 schemarouter.c: Replace strncpy with strcpy
8e85d66 sharding_common.c: Too long a database name handled explicitly
77f4446 Astyle schemarouter
491f7c2 maxinfo.c: Replace strncpy with memcpy
6b98105 maxinfo: Reformat with astyle
c1dbf08 Handle oversize user and database names
5fa4a0f Merge branch 'develop' of ssh://github.com/mariadb-corporation/maxscale-new into develop
706963b BLR_DBUSERS_TAIL new var in blr.h
d75b9af Tweak comments, remove trailing blanks.
ab2400a Optimise statistics gathering by inline & simpler fns.
fb59ddc Remove unnecessary strncpy/strncat usage in Binlog Server
bdcd551 resultset.c: Change strncpy to memcpy
c6b1c5e Reject rather than cut too long a path
6d8f112 Remove unnecessary strncpy/strncat usage
18bf5ed Remove unnecessary strncpy usage
dc0e2db Make maxpasswd more userfriendly
c9c8695 Fix calculation of padded_len in encryptPassword
2cfd2c6 dbusers.c: Check strncpy usage
7ab9342 Make more thorough checks in secrets_readKeys
be7d593 Format cli.c debugcli.c testroute.c webserver.c
1ee5efb config.c: Check usage of strncpy
3043b12 gq_utils.c: Unnecessary use of strncpy removed
77874ac Add help to maxkeys
38392a3 Update secrets_writeKeys documentation
2d1325c Make SSL optional in MaxScale's own communication
bda00da Fix avro build failures
b2cb31a Add more OOM macros
41ccf17 Fix strdup usage
a48f732 Fix realloc calls
20771f6 Add forgotten extern "C" block
8faf35a Add maxscale allocation functions
bb47890 Add macros for OOM logging
afea388 Fix silly mistakes.
6dafd22 Make deny default for null auth; move code from common to auth.
This commit is contained in:
Johan Wikman
2016-08-17 08:36:01 +03:00
parent b2035745fc
commit dc7f7b6fb4
360 changed files with 11641 additions and 15856 deletions
Download Patch File Download Diff File Expand all files Collapse all files

491
server/core/session.c
View File

@ -4,7 +4,7 @@
* Use of this software is governed by the Business Source License included
* in the LICENSE.TXT file and at www.mariadb.com/bsl.
*
* Change Date: 2019-01-01
* Change Date: 2019-07-01
*
* On the date above, in accordance with the Business Source License, use
* of this software will be governed by version 2 or later of the General
@ -23,6 +23,7 @@
* 29/05/14 Mark Riddoch Addition of filter mechanism
* 23/08/15 Martin Brampton Tidying; slight improvement in safety
* 17/09/15 Martin Brampton Keep failed session in existence - leave DCBs to close
* 27/06/16 Martin Brampton Amend to utilise list manager
*
* @endverbatim
*/
@ -31,7 +32,9 @@
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <maxscale/alloc.h>
#include <session.h>
#include <listmanager.h>
#include <service.h>
#include <router.h>
#include <dcb.h>
@ -41,14 +44,15 @@
#include <log_manager.h>
#include <housekeeper.h>
/** Global session id; updated safely by holding session_spin */
static size_t session_id;
/* This list of all sessions */
LIST_CONFIG SESSIONlist =
{LIST_TYPE_RECYCLABLE, sizeof(SESSION), SPINLOCK_INIT};
static SPINLOCK session_spin = SPINLOCK_INIT;
static SESSION *allSessions = NULL;
static SESSION *lastSession = NULL;
static SESSION *wasfreeSession = NULL;
static int freeSessionCount = 0;
/* A session with null values, used for initialization */
static SESSION session_initialized = SESSION_INIT;
/** Global session id; updated safely by use of atomic_add */
static int session_id;
static struct session session_dummy_struct;
@ -60,11 +64,43 @@ long next_timeout_check = 0;
static SPINLOCK timeout_lock = SPINLOCK_INIT;
static void session_initialize(void *session);
static int session_setup_filters(SESSION *session);
static void session_simple_free(SESSION *session, DCB *dcb);
static void session_add_to_all_list(SESSION *session);
static SESSION *session_find_free();
static void session_final_free(SESSION *session);
static list_entry_t *skip_maybe_to_next_non_listener(list_entry_t *current, SESSIONLISTFILTER filter);
/**
* @brief Initialize a session
*
* This routine puts initial values into the fields of the session pointed to
* by the parameter. The parameter has to be passed as void * because the
* function can be called by the generic list manager, which does not know
* the actual type of the list entries it handles.
*
* All fields can be initialized by the assignment of the static
* initialized session.
*
* @param *session Pointer to the session to be initialized
*/
static void
session_initialize(void *session)
{
*(SESSION *)session = session_initialized;
}
/*
* @brief Pre-allocate memory for a number of sessions
*
* @param The number of sessions to be pre-allocated
*/
bool
session_pre_alloc(int number)
{
return list_pre_alloc(&SESSIONlist, number, session_initialize);
}
/**
* Allocate a new session for a new client of the specified service.
@ -82,32 +118,17 @@ session_alloc(SERVICE *service, DCB *client_dcb)
{
SESSION *session;
spinlock_acquire(&session_spin);
session = session_find_free();
spinlock_release(&session_spin);
session = (SESSION *)list_find_free(&SESSIONlist, session_initialize);
ss_info_dassert(session != NULL, "Allocating memory for session failed.");
if (session == NULL)
if (NULL == session)
{
char errbuf[STRERROR_BUFLEN];
MXS_ERROR("Failed to allocate memory for "
"session object due error %d, %s.",
errno,
strerror_r(errno, errbuf, sizeof(errbuf)));
MXS_OOM();
return NULL;
}
#if defined(SS_DEBUG)
session->ses_chk_top = CHK_NUM_SESSION;
session->ses_chk_tail = CHK_NUM_SESSION;
#endif
session->ses_is_child = (bool) DCB_IS_CLONE(client_dcb);
spinlock_init(&session->ses_lock);
session->service = service;
session->client_dcb = client_dcb;
session->n_filters = 0;
memset(&session->stats, 0, sizeof(SESSION_STATS));
session->stats.connect = time(0);
session->state = SESSION_STATE_ALLOC;
/*<
* Associate the session to the client DCB and set the reference count on
* the session to indicate that there is a single reference to the
@ -199,106 +220,17 @@ session_alloc(SERVICE *service, DCB *client_dcb)
session->client_dcb->user,
session->client_dcb->remote);
}
spinlock_acquire(&session_spin);
/** Assign a session id and increase, insert session into list */
session->ses_id = ++session_id;
spinlock_release(&session_spin);
session->ses_id = (size_t)atomic_add(&session_id, 1) + 1;
atomic_add(&service->stats.n_sessions, 1);
atomic_add(&service->stats.n_current, 1);
CHK_SESSION(session);
client_dcb->session = session;
session->entry_is_ready = true;
return SESSION_STATE_TO_BE_FREED == session->state ? NULL : session;
}
/**
* Add a new session to the list of all sessions.
*
* Must be called with the general session lock held.
*
* A pointer, lastSession, is held to find the end of the list, and the new session
* is linked to the end of the list. The pointer, wasfreeSession, that is used to
* search for a free session is initialised if not already set. There cannot be
* any free sessions (or any at all) until this routine has been called at least
* once. Hence it will not be referred to until after it is initialised.
*
* @param session The session to be added to the list
*/
static void
session_add_to_all_list(SESSION *session)
{
if (allSessions == NULL)
{
allSessions = session;
}
else
{
lastSession->next = session;
}
lastSession = session;
if (NULL == wasfreeSession)
{
wasfreeSession = session;
}
}
/**
* Find a free session or allocate memory for a new one.
*
* This routine looks to see whether there are free session memory areas.
* If not, new memory is allocated, if possible, and the new session is added to
* the list of all sessions.
*
* Must be called with the general session lock held.
*
* @return An available session or NULL if none could be allocated.
*/
static SESSION *
session_find_free()
{
SESSION *nextsession;
if (freeSessionCount <= 0)
{
SESSION *newsession;
if ((newsession = calloc(1, sizeof(SESSION))) == NULL)
{
return NULL;
}
newsession->next = NULL;
session_add_to_all_list(newsession);
newsession->ses_is_in_use = true;
return newsession;
}
/* Starting at the last place a free session was found, loop through the */
/* list of sessions searching for one that is not in use. */
while (wasfreeSession->ses_is_in_use)
{
int loopcount = 0;
wasfreeSession = wasfreeSession->next;
if (NULL == wasfreeSession)
{
loopcount++;
if (loopcount > 1)
{
/* Shouldn't need to loop round more than once */
MXS_ERROR("Find free session failed to find a session even"
" though free count was positive");
return NULL;
}
wasfreeSession = allSessions;
}
}
/* Dropping out of the loop means we have found a session that is not in use */
freeSessionCount--;
/* Clear the old data, then reset the list forward link */
nextsession = wasfreeSession->next;
memset(wasfreeSession, 0, sizeof(SESSION));
wasfreeSession->next = nextsession;
wasfreeSession->ses_is_in_use = true;
return wasfreeSession;
}
/**
* Allocate a dummy session so that DCBs can always have sessions.
*
@ -313,10 +245,10 @@ session_set_dummy(DCB *client_dcb)
SESSION *session;
session = &session_dummy_struct;
#if defined(SS_DEBUG)
session->list_entry_chk_top = CHK_NUM_MANAGED_LIST;
session->list_entry_chk_tail = CHK_NUM_MANAGED_LIST;
session->ses_chk_top = CHK_NUM_SESSION;
session->ses_chk_tail = CHK_NUM_SESSION;
#endif
session->ses_is_child = false;
spinlock_init(&session->ses_lock);
session->service = NULL;
@ -405,7 +337,7 @@ session_simple_free(SESSION *session, DCB *dcb)
{
void * clientdata = dcb->data;
dcb->data = NULL;
free(clientdata);
MXS_FREE(clientdata);
}
if (session)
{
@ -487,7 +419,7 @@ session_free(SESSION *session)
session->filters[i].session);
}
}
free(session->filters);
MXS_FREE(session->filters);
}
MXS_INFO("Stopped %s client session [%lu]",
@ -510,10 +442,7 @@ static void
session_final_free(SESSION *session)
{
/* We never free the actual session, it is available for reuse*/
spinlock_acquire(&session_spin);
session->ses_is_in_use = false;
freeSessionCount++;
spinlock_release(&session_spin);
list_free_entry(&SESSIONlist, (list_entry_t *)session);
}
/**
@ -525,21 +454,18 @@ session_final_free(SESSION *session)
int
session_isvalid(SESSION *session)
{
SESSION *list_session;
int rval = 0;
spinlock_acquire(&session_spin);
list_session = allSessions;
while (list_session)
list_entry_t *current = list_start_iteration(&SESSIONlist);
while (current)
{
if (list_session->ses_is_in_use && list_session == session)
if ((SESSION *)current == session)
{
rval = 1;
list_terminate_iteration_early(&SESSIONlist, current);
break;
}
list_session = list_session->next;
current = list_iterate(&SESSIONlist, current);
}
spinlock_release(&session_spin);
return rval;
}
@ -572,19 +498,12 @@ printSession(SESSION *session)
void
printAllSessions()
{
SESSION *list_session;
spinlock_acquire(&session_spin);
list_session = allSessions;
while (list_session)
list_entry_t *current = list_start_iteration(&SESSIONlist);
while (current)
{
if (list_session->ses_is_in_use)
{
printSession(list_session);
}
list_session = list_session->next;
printSession((SESSION *)current);
current = list_iterate(&SESSIONlist, current);
}
spinlock_release(&session_spin);
}
@ -597,19 +516,14 @@ printAllSessions()
void
CheckSessions()
{
SESSION *list_session;
list_entry_t *current;
int noclients = 0;
int norouter = 0;
spinlock_acquire(&session_spin);
list_session = allSessions;
while (list_session)
current = list_start_iteration(&SESSIONlist);
while (current)
{
if (false == list_session->ses_is_in_use)
{
list_session = list_session->next;
continue;
}
SESSION *list_session = (SESSION *)current;
if (list_session->state != SESSION_STATE_LISTENER ||
list_session->state != SESSION_STATE_LISTENER_STOPPED)
{
@ -624,22 +538,16 @@ CheckSessions()
noclients++;
}
}
list_session = list_session->next;
current = list_iterate(&SESSIONlist, current);
}
spinlock_release(&session_spin);
if (noclients)
{
printf("%d Sessions have no clients\n", noclients);
}
spinlock_acquire(&session_spin);
list_session = allSessions;
while (list_session)
current = list_start_iteration(&SESSIONlist);
while (current)
{
if (false == list_session->ses_is_in_use)
{
list_session = list_session->next;
continue;
}
SESSION *list_session = (SESSION *)current;
if (list_session->state != SESSION_STATE_LISTENER ||
list_session->state != SESSION_STATE_LISTENER_STOPPED)
{
@ -654,15 +562,25 @@ CheckSessions()
norouter++;
}
}
list_session = list_session->next;
current = list_iterate(&SESSIONlist, current);
}
spinlock_release(&session_spin);
if (norouter)
{
printf("%d Sessions have no router session\n", norouter);
}
}
/*
* @brief Print session list statistics
*
* @param pdcb DCB to print results to
*/
void
dprintSessionList(DCB *pdcb)
{
dprintListStats(pdcb, &SESSIONlist, "All Sessions");
}
/**
* Print all sessions to a DCB
*
@ -674,24 +592,14 @@ CheckSessions()
void
dprintAllSessions(DCB *dcb)
{
SESSION *list_session;
spinlock_acquire(&session_spin);
list_session = allSessions;
while (list_session)
list_entry_t *current = list_start_iteration(&SESSIONlist);
while (current)
{
if (false == list_session->ses_is_in_use)
{
list_session = list_session->next;
continue;
}
dprintSession(dcb, list_session);
list_session = list_session->next;
dprintSession(dcb, (SESSION *)current);
current = list_iterate(&SESSIONlist, current);
}
spinlock_release(&session_spin);
}
}
/**
* Print a particular session to a DCB
@ -705,35 +613,35 @@ dprintAllSessions(DCB *dcb)
void
dprintSession(DCB *dcb, SESSION *print_session)
{
struct tm result;
char buf[30];
int i;
dcb_printf(dcb, "Session %lu (%p)\n", print_session->ses_id, print_session);
dcb_printf(dcb, "\tState: %s\n", session_state(print_session->state));
dcb_printf(dcb, "\tService: %s (%p)\n", print_session->service->name, print_session->service);
dcb_printf(dcb, "\tClient DCB: %p\n", print_session->client_dcb);
if (print_session->client_dcb && print_session->client_dcb->remote)
{
dcb_printf(dcb, "\tClient Address: %s%s%s\n",
print_session->client_dcb->user ? print_session->client_dcb->user : "",
print_session->client_dcb->user ? "@" : "",
print_session->client_dcb->remote);
}
struct tm result;
char buf[30];
dcb_printf(dcb, "\tConnected: %s", // asctime inserts newline.
asctime_r(localtime_r(&print_session->stats.connect, &result), buf));
if (print_session->client_dcb && print_session->client_dcb->state == DCB_STATE_POLLING)
{
double idle = (hkheartbeat - print_session->client_dcb->last_read);
idle = idle > 0 ? idle / 10.f : 0;
dcb_printf(dcb, "\tIdle: %.0f seconds\n", idle);
idle = idle > 0 ? idle/10.f : 0;
dcb_printf(dcb, "\tClient Address: %s%s%s\n",
print_session->client_dcb->user?print_session->client_dcb->user:"",
print_session->client_dcb->user?"@":"",
print_session->client_dcb->remote);
dcb_printf(dcb, "\tConnected: %s\n",
asctime_r(localtime_r(&print_session->stats.connect, &result), buf));
if (print_session->client_dcb->state == DCB_STATE_POLLING)
{
dcb_printf(dcb, "\tIdle: %.0f seconds\n",idle);
}
}
if (print_session->n_filters)
{
for (int i = 0; i < print_session->n_filters; i++)
for (i = 0; i < print_session->n_filters; i++)
{
dcb_printf(dcb, "\tFilter: %s\n",
print_session->filters[i].filter->name);
@ -755,36 +663,32 @@ dprintSession(DCB *dcb, SESSION *print_session)
void
dListSessions(DCB *dcb)
{
SESSION *list_session;
spinlock_acquire(&session_spin);
list_session = allSessions;
if (list_session)
bool written_heading = false;
list_entry_t *current = list_start_iteration(&SESSIONlist);
if (current)
{
dcb_printf(dcb, "Sessions.\n");
dcb_printf(dcb, "-----------------+-----------------+----------------+--------------------------\n");
dcb_printf(dcb, "Session | Client | Service | State\n");
dcb_printf(dcb, "-----------------+-----------------+----------------+--------------------------\n");
written_heading = true;
}
while (list_session)
while (current)
{
if (list_session->ses_is_in_use)
{
dcb_printf(dcb, "%-16p | %-15s | %-14s | %s\n", list_session,
((list_session->client_dcb && list_session->client_dcb->remote)
? list_session->client_dcb->remote : ""),
(list_session->service && list_session->service->name ? list_session->service->name
: ""),
session_state(list_session->state));
}
list_session = list_session->next;
SESSION *list_session = (SESSION *)current;
dcb_printf(dcb, "%-16p | %-15s | %-14s | %s\n", list_session,
((list_session->client_dcb && list_session->client_dcb->remote)
? list_session->client_dcb->remote : ""),
(list_session->service && list_session->service->name ? list_session->service->name
: ""),
session_state(list_session->state));
current = list_iterate(&SESSIONlist, current);
}
if (allSessions)
if (written_heading)
{
dcb_printf(dcb,
"-----------------+-----------------+----------------+--------------------------\n\n");
}
spinlock_release(&session_spin);
}
/**
@ -821,20 +725,25 @@ session_state(session_state_t state)
}
}
/*
* @brief Find the session that relates to a given router session
*
* @param rses A router session
* @return The related session, or NULL if none
*/
SESSION* get_session_by_router_ses(void* rses)
{
SESSION* ses = allSessions;
while (((ses->ses_is_in_use == false) || (ses->router_session != rses)) && ses->next != NULL)
list_entry_t *current = list_start_iteration(&SESSIONlist);
while (current)
{
ses = ses->next;
if (((SESSION *)current)->router_session == rses)
{
list_terminate_iteration_early(&SESSIONlist, current);
return (SESSION *)current;
}
current = list_iterate(&SESSIONlist, current);
}
if (ses->ses_is_in_use == false || ses->router_session != rses)
{
ses = NULL;
}
return ses;
return NULL;
}
@ -858,11 +767,9 @@ session_setup_filters(SESSION *session)
UPSTREAM *tail;
int i;
if ((session->filters = calloc(service->n_filters,
sizeof(SESSION_FILTER))) == NULL)
if ((session->filters = MXS_CALLOC(service->n_filters,
sizeof(SESSION_FILTER))) == NULL)
{
MXS_ERROR("Insufficient memory to allocate session filter "
"tracking.\n");
return 0;
}
session->n_filters = service->n_filters;
@ -886,7 +793,7 @@ session_setup_filters(SESSION *session)
session->filters[i].session = head->session;
session->filters[i].instance = head->instance;
session->head = *head;
free(head);
MXS_FREE(head);
}
for (i = 0; i < service->n_filters; i++)
@ -909,7 +816,7 @@ session_setup_filters(SESSION *session)
if (tail != &session->tail)
{
session->tail = *tail;
free(tail);
MXS_FREE(tail);
}
}
@ -984,14 +891,6 @@ session_getUser(SESSION *session)
{
return (session && session->client_dcb) ? session->client_dcb->user : NULL;
}
/**
* Return the pointer to the list of all sessions.
* @return Pointer to the list of all sessions.
*/
SESSION *get_all_sessions()
{
return allSessions;
}
/**
* Enable the timing out of idle connections.
@ -1016,24 +915,22 @@ void process_idle_sessions()
{
if (hkheartbeat >= next_timeout_check)
{
list_entry_t *current = list_start_iteration(&SESSIONlist);
/** Because the resolution of the timeout is one second, we only need to
* check for it once per second. One heartbeat is 100 milliseconds. */
next_timeout_check = hkheartbeat + 10;
spinlock_acquire(&session_spin);
SESSION *all_session = allSessions;
while (all_session)
while (current)
{
if (all_session->ses_is_in_use &&
all_session->service && all_session->client_dcb && all_session->client_dcb->state == DCB_STATE_POLLING &&
SESSION *all_session = (SESSION *)current;
if (all_session->service && all_session->client_dcb && all_session->client_dcb->state == DCB_STATE_POLLING &&
hkheartbeat - all_session->client_dcb->last_read > all_session->service->conn_idle_timeout * 10)
{
dcb_close(all_session->client_dcb);
}
all_session = all_session->next;
current = list_iterate(&SESSIONlist, current);
}
spinlock_release(&session_spin);
}
spinlock_release(&timeout_lock);
}
@ -1060,60 +957,72 @@ sessionRowCallback(RESULTSET *set, void *data)
{
SESSIONFILTER *cbdata = (SESSIONFILTER *)data;
int i = 0;
char buf[20];
RESULT_ROW *row;
SESSION *list_session;
list_entry_t *current = list_start_iteration(&SESSIONlist);
spinlock_acquire(&session_spin);
list_session = allSessions;
/* Skip to the first non-listener if not showing listeners */
while (false == list_session->ses_is_in_use ||
(list_session && cbdata->filter == SESSION_LIST_CONNECTION &&
list_session->state == SESSION_STATE_LISTENER))
current = skip_maybe_to_next_non_listener(current, cbdata->filter);
while (i < cbdata->index && current)
{
list_session = list_session->next;
}
while (i < cbdata->index && list_session)
{
if (list_session->ses_is_in_use)
if (cbdata->filter == SESSION_LIST_ALL ||
(cbdata->filter == SESSION_LIST_CONNECTION &&
((SESSION *)current)->state != SESSION_STATE_LISTENER))
{
if (cbdata->filter == SESSION_LIST_CONNECTION &&
list_session->state != SESSION_STATE_LISTENER)
{
i++;
}
else if (cbdata->filter == SESSION_LIST_ALL)
{
i++;
}
i++;
}
list_session = list_session->next;
current = list_iterate(&SESSIONlist, current);
}
/* Skip to the next non-listener if not showing listeners */
while (list_session && (false == list_session->ses_is_in_use ||
(cbdata->filter == SESSION_LIST_CONNECTION &&
list_session->state == SESSION_STATE_LISTENER)))
current = skip_maybe_to_next_non_listener(current, cbdata->filter);
if (NULL == current)
{
list_session = list_session->next;
}
if (list_session == NULL)
{
spinlock_release(&session_spin);
free(data);
MXS_FREE(data);
return NULL;
}
cbdata->index++;
row = resultset_make_row(set);
snprintf(buf,19, "%p", list_session);
buf[19] = '\0';
resultset_row_set(row, 0, buf);
resultset_row_set(row, 1, ((list_session->client_dcb && list_session->client_dcb->remote)
else
{
char buf[20];
RESULT_ROW *row;
SESSION *list_session = (SESSION *)current;
cbdata->index++;
row = resultset_make_row(set);
snprintf(buf,19, "%p", list_session);
buf[19] = '\0';
resultset_row_set(row, 0, buf);
resultset_row_set(row, 1, ((list_session->client_dcb && list_session->client_dcb->remote)
? list_session->client_dcb->remote : ""));
resultset_row_set(row, 2, (list_session->service && list_session->service->name
resultset_row_set(row, 2, (list_session->service && list_session->service->name
? list_session->service->name : ""));
resultset_row_set(row, 3, session_state(list_session->state));
spinlock_release(&session_spin);
return row;
resultset_row_set(row, 3, session_state(list_session->state));
list_terminate_iteration_early(&SESSIONlist, current);
return row;
}
}
/*
* @brief Skip to the next non-listener session, if not showing listeners
*
* Based on a test of the filter that is the second parameter, along with the
* state of the sessions.
*
* @param current The session to start the possible skipping
* @param filter The filter the defines the operation
*
* @result The first session beyond those skipped, or the starting session;
* NULL if the list of sessions is exhausted.
*/
static list_entry_t *skip_maybe_to_next_non_listener(list_entry_t *current, SESSIONLISTFILTER filter)
{
/* Skip to the first non-listener if not showing listeners */
while (current && filter == SESSION_LIST_CONNECTION &&
((SESSION *)current)->state == SESSION_STATE_LISTENER)
{
current = list_iterate(&SESSIONlist, current);
}
return current;
}
/**
@ -1133,7 +1042,7 @@ sessionGetList(SESSIONLISTFILTER filter)
RESULTSET *set;
SESSIONFILTER *data;
if ((data = (SESSIONFILTER *)malloc(sizeof(SESSIONFILTER))) == NULL)
if ((data = (SESSIONFILTER *)MXS_MALLOC(sizeof(SESSIONFILTER))) == NULL)
{
return NULL;
}
@ -1141,7 +1050,7 @@ sessionGetList(SESSIONLISTFILTER filter)
data->filter = filter;
if ((set = resultset_create(sessionRowCallback, data)) == NULL)
{
free(data);
MXS_FREE(data);
return NULL;
}
resultset_add_column(set, "Session", 16, COL_TYPE_VARCHAR);