hcq/MaxScale
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
241112972df1edea13c781c7a50ff9ebb0ab9e4d
MaxScale/server/core/skygw_utils.cc
Johan Wikman 5648f708af Update license to BSL 1.1
2017-02-14 21:42:28 +02:00

1021 lines
24 KiB
C++
Raw Blame History

/*
* Copyright (c) 2016 MariaDB Corporation Ab
*
* Use of this software is governed by the Business Source License included
* in the LICENSE.TXT file and at www.mariadb.com/bsl11.
*
* 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
* Public License.
*/
#ifndef PCRE2_CODE_UNIT_WIDTH
#define PCRE2_CODE_UNIT_WIDTH 8
#endif
#include <ctype.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <errno.h>
#include <string.h>
#include <time.h>
#include <stddef.h>
#include <regex.h>
#include <maxscale/debug.h>
#include <sys/time.h>
#include "maxscale/skygw_utils.h"
#include <maxscale/atomic.h>
#include <maxscale/random_jkiss.h>
#include <pcre2.h>
#if !defined(PATH_MAX)
# if defined(__USE_POSIX)
# define PATH_MAX _POSIX_PATH_MAX
# else
# define PATH_MAX 256
# endif
#endif
static void simple_mutex_free_memory(simple_mutex_t* sm);
static void thread_free_memory(skygw_thread_t* th, char* name);
/** End of static function declarations */
int skygw_rwlock_rdlock(skygw_rwlock_t* rwlock)
{
int err = pthread_rwlock_rdlock(rwlock->srw_rwlock);
if (err == 0)
{
rwlock->srw_rwlock_thr = pthread_self();
}
else
{
rwlock->srw_rwlock_thr = 0;
char errbuf[MXS_STRERROR_BUFLEN];
ss_dfprintf(stderr,
"* pthread_rwlock_rdlock : %s\n",
strerror_r(err, errbuf, sizeof (errbuf)));
}
return err;
}
int skygw_rwlock_wrlock(skygw_rwlock_t* rwlock)
{
int err = pthread_rwlock_wrlock(rwlock->srw_rwlock);
if (err == 0)
{
rwlock->srw_rwlock_thr = pthread_self();
}
else
{
rwlock->srw_rwlock_thr = 0;
char errbuf[MXS_STRERROR_BUFLEN];
ss_dfprintf(stderr,
"* pthread_rwlock_wrlock : %s\n",
strerror_r(err, errbuf, sizeof (errbuf)));
}
return err;
}
int skygw_rwlock_unlock(skygw_rwlock_t* rwlock)
{
int err = pthread_rwlock_rdlock(rwlock->srw_rwlock);
if (err == 0)
{
rwlock->srw_rwlock_thr = 0;
}
else
{
char errbuf[MXS_STRERROR_BUFLEN];
ss_dfprintf(stderr, "* pthread_rwlock_unlock : %s\n",
strerror_r(err, errbuf, sizeof (errbuf)));
}
return err;
}
int skygw_rwlock_destroy(skygw_rwlock_t* rwlock)
{
int err;
/** Lock */
if ((err = pthread_rwlock_wrlock(rwlock->srw_rwlock)) != 0)
{
char errbuf[MXS_STRERROR_BUFLEN];
fprintf(stderr, "* Error : pthread_rwlock_wrlock failed due to %d, %s.\n",
err, strerror_r(err, errbuf, sizeof (errbuf)));
goto retblock;
}
/** Clean the struct */
rwlock->srw_rwlock_thr = 0;
/** Unlock */
pthread_rwlock_unlock(rwlock->srw_rwlock);
/** Destroy */
if ((err = pthread_rwlock_destroy(rwlock->srw_rwlock)) != 0)
{
char errbuf[MXS_STRERROR_BUFLEN];
fprintf(stderr, "* Error : pthread_rwlock_destroy failed due to %d,%s\n",
err, strerror_r(err, errbuf, sizeof (errbuf)));
}
else
{
rwlock->srw_rwlock = NULL;
}
retblock:
return err;
}
int skygw_rwlock_init(skygw_rwlock_t** rwlock)
{
skygw_rwlock_t* rwl;
int err;
rwl = (skygw_rwlock_t *) calloc(1, sizeof (skygw_rwlock_t));
if (rwl == NULL)
{
err = 1;
goto return_err;
}
rwl->srw_chk_top = CHK_NUM_RWLOCK;
rwl->srw_chk_tail = CHK_NUM_RWLOCK;
err = pthread_rwlock_init(rwl->srw_rwlock, NULL);
ss_dassert(err == 0);
if (err != 0)
{
free(rwl);
char errbuf[MXS_STRERROR_BUFLEN];
ss_dfprintf(stderr, "* Creating pthread_rwlock failed : %s\n",
strerror_r(err, errbuf, sizeof (errbuf)));
goto return_err;
}
*rwlock = rwl;
return_err:
return err;
}
size_t get_timestamp_len(void)
{
return timestamp_len;
}
size_t get_timestamp_len_hp(void)
{
return timestamp_len_hp;
}
/**
* @node Generate and write a timestamp to location passed as argument
* by using at most tslen characters.
*
* Parameters:
* @param p_ts - in, use
* Write position in memory. Must be filled with at least
* <timestamp_len> zeroes
*
* @return Length of string written to p_ts. Length includes terminating '\0'.
*
*
* @details (write detailed description here)
*
*/
size_t snprint_timestamp(char* p_ts, size_t tslen)
{
time_t t;
struct tm tm;
size_t rval;
struct timeval tv;
if (p_ts == NULL)
{
rval = 0;
goto retblock;
}
/** Generate timestamp */
t = time(NULL);
localtime_r(&t, &tm);
snprintf(p_ts, MXS_MIN(tslen, timestamp_len), timestamp_formatstr,
tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour,
tm.tm_min, tm.tm_sec);
rval = strlen(p_ts) * sizeof (char);
retblock:
return rval;
}
/**
* @node Generate and write a timestamp to location passed as argument
* by using at most tslen characters. This will use millisecond precision.
*
* Parameters:
* @param p_ts - in, use
* Write position in memory. Must be filled with at least
* <timestamp_len> zeroes
*
* @return Length of string written to p_ts. Length includes terminating '\0'.
*
*
* @details (write detailed description here)
*
*/
size_t snprint_timestamp_hp(char* p_ts, size_t tslen)
{
time_t t;
struct tm tm;
size_t rval;
struct timeval tv;
int usec;
if (p_ts == NULL)
{
rval = 0;
goto retblock;
}
/** Generate timestamp */
gettimeofday(&tv, NULL);
localtime_r(&tv.tv_sec, &tm);
usec = tv.tv_usec / 1000;
snprintf(p_ts, MXS_MIN(tslen, timestamp_len_hp), timestamp_formatstr_hp,
tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
tm.tm_hour, tm.tm_min, tm.tm_sec, usec);
rval = strlen(p_ts) * sizeof (char);
retblock:
return rval;
}
/**
* @node Initialize thread data structure
*
* Parameters:
* @param name copy is taken and stored to thread structure
*
* @param sth_thrfun - <usage>
* <description>
*
* @param data thread data pointer
*
* @return thread pointer or NULL in case of failure
*
*
* @details (write detailed description here)
*
*/
skygw_thread_t* skygw_thread_init(const char* name, void* (*sth_thrfun)(void* data),
void* data)
{
skygw_thread_t* th = (skygw_thread_t *) calloc(1, sizeof (skygw_thread_t));
if (th == NULL)
{
fprintf(stderr, "* Memory allocation for thread failed\n");
goto return_th;
}
ss_dassert(th != NULL);
th->sth_chk_top = CHK_NUM_THREAD;
th->sth_chk_tail = CHK_NUM_THREAD;
th->sth_parent = pthread_self();
ss_debug(th->sth_state = THR_INIT);
th->sth_name = strndup(name, PATH_MAX);
th->sth_mutex = simple_mutex_init(NULL, name);
if (th->sth_mutex == NULL)
{
thread_free_memory(th, th->sth_name);
th = NULL;
goto return_th;
}
th->sth_thrfun = sth_thrfun;
th->sth_data = data;
CHK_THREAD(th);
return_th:
return th;
}
static void thread_free_memory(skygw_thread_t* th, char* name)
{
free(name);
free(th);
}
/**
* @node Release skygw_thread data except filewriter.
*
* Parameters:
* @param th - <usage>
* <description>
*
* @return void
*
*
* @details (write detailed description here)
*
*/
void skygw_thread_done(skygw_thread_t* th)
{
if (th != NULL)
{
CHK_THREAD(th);
ss_dassert(th->sth_state == THR_STOPPED);
ss_debug(th->sth_state = THR_DONE);
simple_mutex_done(th->sth_mutex);
pthread_join(th->sth_thr, NULL);
thread_free_memory(th, th->sth_name);
}
}
pthread_t skygw_thread_gettid(skygw_thread_t* thr)
{
CHK_THREAD(thr);
return thr->sth_thr;
}
int skygw_thread_start(skygw_thread_t* thr)
{
int err;
CHK_THREAD(thr);
err = pthread_create(&thr->sth_thr, NULL, thr->sth_thrfun, thr);
ss_dassert(err == 0);
if (err != 0)
{
char errbuf[MXS_STRERROR_BUFLEN];
fprintf(stderr, "* Starting file writer thread failed due error, %d, %s\n",
err, strerror_r(errno, errbuf, sizeof (errbuf)));
goto return_err;
}
return_err:
return err;
}
#if defined(SS_DEBUG)
skygw_thr_state_t skygw_thread_get_state(skygw_thread_t* thr)
{
CHK_THREAD(thr);
return thr->sth_state;
}
#endif
/**
* @node Update thread state
*
* Parameters:
* @param thr - <usage>
* <description>
*
* @param state - <usage>
* <description>
*
* @return void
*
*
* @details Thread must check state with mutex.
*
*/
#if defined(SS_DEBUG)
void skygw_thread_set_state(skygw_thread_t* thr, skygw_thr_state_t state)
{
CHK_THREAD(thr);
simple_mutex_lock(thr->sth_mutex, true);
thr->sth_state = state;
simple_mutex_unlock(thr->sth_mutex);
}
#endif
/**
* @node Set exit flag for thread from other thread
*
* Parameters:
* @param thr - <usage>
* <description>
*
* @return
*
*
* @details This call informs thread about exit flag and waits the response.
*
*/
bool skygw_thread_set_exitflag(skygw_thread_t* thr, skygw_message_t* sendmes,
skygw_message_t* recmes)
{
bool succp = false;
/**
* If thread struct pointer is NULL there's running thread
* neither.
*/
if (thr == NULL)
{
succp = true;
goto return_succp;
}
CHK_THREAD(thr);
CHK_MESSAGE(sendmes);
CHK_MESSAGE(recmes);
simple_mutex_lock(thr->sth_mutex, true);
succp = !thr->sth_must_exit;
thr->sth_must_exit = true;
simple_mutex_unlock(thr->sth_mutex);
/** Inform thread and wait for response */
if (succp)
{
skygw_message_send(sendmes);
skygw_message_wait(recmes);
}
ss_dassert(thr->sth_state == THR_STOPPED);
return_succp:
return succp;
}
void* skygw_thread_get_data(skygw_thread_t* thr)
{
CHK_THREAD(thr);
return thr->sth_data;
}
bool skygw_thread_must_exit(skygw_thread_t* thr)
{
CHK_THREAD(thr);
return thr->sth_must_exit;
}
void acquire_lock(int* l)
{
register int misscount = 0;
struct timespec ts1;
ts1.tv_sec = 0;
while (atomic_add(l, 1) != 0)
{
atomic_add(l, -1);
misscount += 1;
if (misscount > 10)
{
ts1.tv_nsec = (random_jkiss() % misscount) * 1000000;
nanosleep(&ts1, NULL);
}
}
}
void release_lock(int* l)
{
atomic_add(l, -1);
}
/**
* @node Create a simple_mutex structure which encapsulates pthread_mutex.
*
* Parameters:
* @param mutexptr if mutex is initialized within caller's memory, this is
* the address for it. If mutex is flat, there is value, otherwise it is NULL.
*
* @param name name of mutex, passed argument is copied and pointer is stored
* to mutex struct.
*
* @return simple_mutex pointer or NULL in case of failure.
*
*
* @details If mutex is flat, sm_enabled can be read if the memory is not freed.
* If flat mutex exists, sm_enabled is true.
* If mutex allocates its own memory, the pointer is NULL if mutex doesn't
* exist.
*
*/
simple_mutex_t* simple_mutex_init(simple_mutex_t* mutexptr, const char* name)
{
int err;
simple_mutex_t* sm;
/** Copy pointer only if flat, allocate memory otherwise. */
if (mutexptr != NULL)
{
sm = mutexptr;
sm->sm_flat = true;
}
else
{
sm = (simple_mutex_t *) calloc(1, sizeof (simple_mutex_t));
}
ss_dassert(sm != NULL);
#if defined(SS_DEBUG)
sm->sm_chk_top = CHK_NUM_SIMPLE_MUTEX;
sm->sm_chk_tail = CHK_NUM_SIMPLE_MUTEX;
#endif
sm->sm_name = strndup(name, PATH_MAX);
/** Create pthread mutex */
err = pthread_mutex_init(&sm->sm_mutex, NULL);
if (err != 0)
{
char errbuf[MXS_STRERROR_BUFLEN];
fprintf(stderr, "* Initializing simple mutex %s failed due error %d, %s\n",
name, err, strerror_r(errno, errbuf, sizeof (errbuf)));
perror("simple_mutex : ");
/** Write zeroes if flat, free otherwise. */
if (sm->sm_flat)
{
memset(sm, 0, sizeof (*sm));
}
else
{
simple_mutex_free_memory(sm);
sm = NULL;
}
goto return_sm;
}
sm->sm_enabled = true;
CHK_SIMPLE_MUTEX(sm);
return_sm:
return sm;
}
int simple_mutex_done(simple_mutex_t* sm)
{
int err = 0;
CHK_SIMPLE_MUTEX(sm);
if (atomic_add(&sm->sm_enabled, -1) != 1)
{
atomic_add(&sm->sm_enabled, 1);
}
err = pthread_mutex_destroy(&sm->sm_mutex);
#if defined(NOT_USED)
if (err != 0)
{
perror("simple_mutex : ");
char errbuf[MXS_STRERROR_BUFLEN];
fprintf(stderr, "* Destroying simple mutex %s failed due %d, %s\n",
sm->sm_name, err, strerror_r(errno, errbuf, sizeof (errbuf)));
goto return_err;
}
#endif
simple_mutex_free_memory(sm);
#if defined(NOT_USED)
return_err:
#endif
return err;
}
static void simple_mutex_free_memory(simple_mutex_t* sm)
{
if (sm->sm_name != NULL)
{
free(sm->sm_name);
}
if (!sm->sm_flat)
{
free(sm);
}
}
int simple_mutex_lock(simple_mutex_t* sm, bool block)
{
int err;
/**
* Leaving the following serves as a reminder. It may assert
* any given time because sm_lock_thr is not protected.
*
* ss_dassert(sm->sm_lock_thr != pthread_self());
*/
if (block)
{
err = pthread_mutex_lock(&sm->sm_mutex);
}
else
{
err = pthread_mutex_trylock(&sm->sm_mutex);
}
if (err != 0)
{
char errbuf[MXS_STRERROR_BUFLEN];
fprintf(stderr, "* Locking simple mutex %s failed due error, %d, %s\n",
sm->sm_name, err, strerror_r(errno, errbuf, sizeof (errbuf)));
perror("simple_mutex : ");
}
else
{
/**
* Note that these updates are not protected.
*/
sm->sm_locked = true;
sm->sm_lock_thr = pthread_self();
}
return err;
}
int simple_mutex_unlock(simple_mutex_t* sm)
{
int err;
/**
* Leaving the following serves as a reminder. It may assert
* any given time because sm_lock_thr is not protected.
*
* ss_dassert(sm->sm_lock_thr == pthread_self());
*/
err = pthread_mutex_unlock(&sm->sm_mutex);
if (err != 0)
{
char errbuf[MXS_STRERROR_BUFLEN];
fprintf(stderr, "* Unlocking simple mutex %s failed due error %d, %s\n",
sm->sm_name, err, strerror_r(errno, errbuf, sizeof (errbuf)));
perror("simple_mutex : ");
}
else
{
/**
* Note that these updates are not protected.
*/
sm->sm_locked = false;
sm->sm_lock_thr = 0;
}
return err;
}
skygw_message_t* skygw_message_init(void)
{
int err;
skygw_message_t* mes;
mes = (skygw_message_t*) calloc(1, sizeof (skygw_message_t));
if (mes == NULL)
{
err = 1;
goto return_mes;
}
mes->mes_chk_top = CHK_NUM_MESSAGE;
mes->mes_chk_tail = CHK_NUM_MESSAGE;
err = pthread_mutex_init(&(mes->mes_mutex), NULL);
if (err != 0)
{
char errbuf[MXS_STRERROR_BUFLEN];
fprintf(stderr, "* Initializing pthread mutex failed due error %d, %s\n",
err, strerror_r(errno, errbuf, sizeof (errbuf)));
free(mes);
mes = NULL;
goto return_mes;
}
err = pthread_cond_init(&(mes->mes_cond), NULL);
if (err != 0)
{
char errbuf[MXS_STRERROR_BUFLEN];
fprintf(stderr, "* Initializing pthread cond var failed, due error %d, %s\n",
err, strerror_r(errno, errbuf, sizeof (errbuf)));
pthread_mutex_destroy(&mes->mes_mutex);
free(mes);
mes = NULL;
goto return_mes;
}
CHK_MESSAGE(mes);
return_mes:
return mes;
}
void skygw_message_done(skygw_message_t* mes)
{
int err;
/**
* If message struct pointer is NULL there's nothing to free.
*/
if (mes == NULL)
{
return;
}
CHK_MESSAGE(mes);
err = pthread_cond_destroy(&(mes->mes_cond));
if (err != 0)
{
char errbuf[MXS_STRERROR_BUFLEN];
fprintf(stderr, "* Destroying cond var failed due error %d, %s\n",
err, strerror_r(errno, errbuf, sizeof (errbuf)));
}
ss_dassert(err == 0);
err = pthread_mutex_destroy(&(mes->mes_mutex));
if (err != 0)
{
char errbuf[MXS_STRERROR_BUFLEN];
fprintf(stderr, "* Destroying pthread mutex failed, due error %d, %s\n",
err, strerror_r(errno, errbuf, sizeof (errbuf)));
}
ss_dassert(err == 0);
free(mes);
}
skygw_mes_rc_t skygw_message_send(skygw_message_t* mes)
{
int err;
skygw_mes_rc_t rc = MES_RC_FAIL;
CHK_MESSAGE(mes);
err = pthread_mutex_lock(&(mes->mes_mutex));
if (err != 0)
{
char errbuf[MXS_STRERROR_BUFLEN];
fprintf(stderr, "* Locking pthread mutex failed, due to error %d, %s\n",
err, strerror_r(errno, errbuf, sizeof (errbuf)));
goto return_mes_rc;
}
mes->mes_sent = true;
err = pthread_cond_signal(&(mes->mes_cond));
if (err == 0)
{
rc = MES_RC_SUCCESS;
}
else
{
char errbuf[MXS_STRERROR_BUFLEN];
fprintf(stderr, "* Signaling pthread cond var failed, due to error %d, %s\n",
err, strerror_r(errno, errbuf, sizeof (errbuf)));
}
err = pthread_mutex_unlock(&(mes->mes_mutex));
if (err != 0)
{
char errbuf[MXS_STRERROR_BUFLEN];
fprintf(stderr, "* Unlocking pthread mutex failed, due to error %d, %s\n",
err, strerror_r(errno, errbuf, sizeof (errbuf)));
}
return_mes_rc:
return rc;
}
void skygw_message_wait(skygw_message_t* mes)
{
int err;
CHK_MESSAGE(mes);
err = pthread_mutex_lock(&(mes->mes_mutex));
if (err != 0)
{
char errbuf[MXS_STRERROR_BUFLEN];
fprintf(stderr, "* Locking pthread mutex failed, due error %d, %s\n",
err, strerror_r(errno, errbuf, sizeof (errbuf)));
}
ss_dassert(err == 0);
while (!mes->mes_sent)
{
err = pthread_cond_wait(&(mes->mes_cond), &(mes->mes_mutex));
if (err != 0)
{
char errbuf[MXS_STRERROR_BUFLEN];
fprintf(stderr, "* Locking pthread cond wait failed, due error %d, %s\n",
err, strerror_r(errno, errbuf, sizeof (errbuf)));
}
}
mes->mes_sent = false;
err = pthread_mutex_unlock(&(mes->mes_mutex));
if (err != 0)
{
char errbuf[MXS_STRERROR_BUFLEN];
fprintf(stderr, "* Unlocking pthread mutex failed, due error %d, %s\n",
err, strerror_r(errno, errbuf, sizeof (errbuf)));
}
ss_dassert(err == 0);
}
void skygw_message_reset(skygw_message_t* mes)
{
int err;
CHK_MESSAGE(mes);
err = pthread_mutex_lock(&(mes->mes_mutex));
if (err != 0)
{
char errbuf[MXS_STRERROR_BUFLEN];
fprintf(stderr, "* Locking pthread mutex failed, due error %d, %s\n",
err, strerror_r(errno, errbuf, sizeof (errbuf)));
goto return_mes_rc;
}
ss_dassert(err == 0);
mes->mes_sent = false;
err = pthread_mutex_unlock(&(mes->mes_mutex));
if (err != 0)
{
char errbuf[MXS_STRERROR_BUFLEN];
fprintf(stderr, "* Unlocking pthread mutex failed, due error %d, %s\n",
err, strerror_r(errno, errbuf, sizeof (errbuf)));
goto return_mes_rc;
}
return_mes_rc:
ss_dassert(err == 0);
}
/**
* Write data to a file.
*
* @param file write target
* @param data pointer to contiguous memory buffer
* @param nbytes amount of bytes to be written
* @param flush ensure that write is permanent
*
* @return 0 if succeed, errno if failed.
*/
int skygw_file_write(skygw_file_t* file, void* data, size_t nbytes, bool flush)
{
int rc;
size_t nwritten;
int fd;
static int writecount;
CHK_FILE(file);
nwritten = fwrite(data, nbytes, 1, file->sf_file);
if (nwritten != 1)
{
rc = errno;
perror("Logfile write.\n");
fprintf(stderr, "* Writing %ld bytes,\n%s\n to %s failed.\n",
nbytes, (char *) data, file->sf_fname);
goto return_rc;
}
writecount += 1;
if (flush || writecount == FSYNCLIMIT)
{
fd = fileno(file->sf_file);
fflush(file->sf_file);
fsync(fd);
writecount = 0;
}
rc = 0;
CHK_FILE(file);
return_rc:
return rc;
}
skygw_file_t* skygw_file_alloc(const char* fname)
{
skygw_file_t* file;
if ((file = (skygw_file_t *) calloc(1, sizeof (skygw_file_t))) == NULL)
{
fprintf(stderr, "* Error : Memory allocation for file %s failed.\n", fname);
perror("File allocation failed\n");
return NULL;
}
ss_dassert(file != NULL);
file->sf_chk_top = CHK_NUM_FILE;
file->sf_chk_tail = CHK_NUM_FILE;
file->sf_fname = strdup(fname);
return file;
}
skygw_file_t* skygw_file_init(const char* fname,
const char* symlinkname,
skygw_open_mode_t mode)
{
skygw_file_t* file;
if ((file = skygw_file_alloc(fname)) == NULL)
{
/** Error was reported in skygw_file_alloc */
goto return_file;
}
const char* mode_string;
switch (mode)
{
case SKYGW_OPEN_TRUNCATE:
mode_string = "w";
break;
default:
ss_dassert(!true);
case SKYGW_OPEN_APPEND:
mode_string = "a";
};
if ((file->sf_file = fopen(file->sf_fname, mode_string)) == NULL)
{
int eno = errno;
errno = 0;
char errbuf[MXS_STRERROR_BUFLEN];
fprintf(stderr, "* Opening file %s failed due %d, %s.\n",
file->sf_fname, eno, strerror_r(eno, errbuf, sizeof (errbuf)));
free(file);
file = NULL;
goto return_file;
}
setvbuf(file->sf_file, NULL, _IONBF, 0);
CHK_FILE(file);
/**
* Create symlink to newly created file if name was provided.
*/
if (symlinkname != NULL)
{
unlink(symlinkname);
int rc = symlink(fname, symlinkname);
if (rc != 0)
{
int eno = errno;
errno = 0;
char errbuf[MXS_STRERROR_BUFLEN];
fprintf(stderr, "failed to create symlink %s -> %s due %d, %s. Exiting.",
fname, symlinkname, eno, strerror_r(eno, errbuf, sizeof (errbuf)));
free(file);
file = NULL;
goto return_file;
}
}
return_file:
return file;
}
void skygw_file_free(skygw_file_t* file)
{
if (file)
{
free(file->sf_fname);
free(file);
}
}
void skygw_file_close(skygw_file_t* file)
{
int fd;
int err;
if (file != NULL)
{
CHK_FILE(file);
fd = fileno(file->sf_file);
fsync(fd);
if ((err = fclose(file->sf_file)) != 0)
{
char errbuf[MXS_STRERROR_BUFLEN];
fprintf(stderr, "* Closing file %s failed due to %d, %s.\n",
file->sf_fname, errno, strerror_r(errno, errbuf, sizeof (errbuf)));
}
else
{
ss_dfprintf(stderr, "Closed %s\n", file->sf_fname);
skygw_file_free(file);
}
}
}
/**
* Calculate the number of decimal numbers from a size_t value.
*
* @param value value
*
* @return number of decimal numbers of which the value consists of
* value==123 returns 3, for example.
* @note Does the same as UINTLEN macro
*/
size_t get_decimal_len(
size_t value)
{
return value > 0 ? (size_t) log10((double) value) + 1 : 1;
}
Reference in New Issue View Git Blame Copy Permalink