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

Replace strerror_r with mxs_strerror

Browse Source 
The mxs_strerror function requires no local buffer, thus making it simpler
and cleaner to use.
This commit is contained in:
Markus Mäkelä 2017-03-07 12:18:53 +02:00
parent d7e48f93bb
commit e1a1959bc2
33 changed files with 174 additions and 337 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
avro/maxavro_file.c
View File

@ -27,9 +27,8 @@ static bool maxavro_read_sync(FILE *file, uint8_t* sync)
if (ferror(file))
{
char err[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to read file sync marker: %d, %s", errno,
strerror_r(errno, err, sizeof(err)));
mxs_strerror(errno));
}
else if (feof(file))
{
@ -52,8 +51,7 @@ bool maxavro_verify_block(MAXAVRO_FILE *file)
{
if (ferror(file->file))
{
char err[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to read file: %d %s", errno, strerror_r(errno, err, sizeof(err)));
MXS_ERROR("Failed to read file: %d %s", errno, mxs_strerror(errno));
}
else if (rc > 0 || !feof(file->file))
{
@ -181,9 +179,8 @@ bool maxavro_read_datablock_start(MAXAVRO_FILE* file)
if (pos == -1)
{
char err[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to read datablock start: %d, %s", errno,
strerror_r(errno, err, sizeof(err)));
mxs_strerror(errno));
}
else
{
@ -421,9 +418,8 @@ GWBUF* maxavro_file_binary_header(MAXAVRO_FILE *file)
{
if (ferror(file->file))
{
char err[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to read binary header: %d, %s", errno,
strerror_r(errno, err, sizeof(err)));
mxs_strerror(errno));
}
else if (feof(file->file))
{
@ -444,9 +440,8 @@ GWBUF* maxavro_file_binary_header(MAXAVRO_FILE *file)
}
else
{
char err[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to read binary header: %d, %s", errno,
strerror_r(errno, err, sizeof(err)));
mxs_strerror(errno));
}
return rval;

3
avro/maxavro_record.c
View File

@ -325,9 +325,8 @@ GWBUF* maxavro_record_read_binary(MAXAVRO_FILE *file)
{
if (ferror(file->file))
{
char err[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to read %ld bytes: %d, %s", data_size, errno,
strerror_r(errno, err, sizeof(err)));
mxs_strerror(errno));
file->last_error = MAXAVRO_ERR_IO;
}
gwbuf_free(rval);

4
server/core/buffer.c
View File

@ -94,9 +94,7 @@ gwbuf_alloc(unsigned int size)
retblock:
if (rval == NULL)
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("Memory allocation failed due to %s.",
strerror_r(errno, errbuf, sizeof(errbuf)));
MXS_ERROR("Memory allocation failed due to %s.", mxs_strerror(errno));
}
#if defined(BUFFER_TRACE)
else

10
server/core/config.c
View File

@ -541,9 +541,8 @@ static bool is_directory(const char *dir)
}
else
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_WARNING("Could not access %s, not reading: %s",
dir, strerror_r(errno, errbuf, sizeof(errbuf)));
dir, mxs_strerror(errno));
}
}
else
@ -2365,9 +2364,7 @@ bool config_has_duplicate_sections(const char* filename, DUPLICATE_CONTEXT* cont
}
else
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to open file '%s': %s", filename,
strerror_r(errno, errbuf, sizeof(errbuf)));
MXS_ERROR("Failed to open file '%s': %s", filename, mxs_strerror(errno));
rval = true;
}
}
@ -3255,9 +3252,8 @@ static bool check_path_parameter(const MXS_MODULE_PARAM *params, const char *val
}
else
{
char err[MXS_STRERROR_BUFLEN];
MXS_ERROR("Bad path parameter '%s' (absolute path '%s'): %d, %s", value,
buf, errno, strerror_r(errno, err, sizeof(err)));
buf, errno, mxs_strerror(errno));
}
}
else

9
server/core/config_runtime.c
View File

@ -176,9 +176,8 @@ bool runtime_destroy_server(SERVER *server)
{
if (errno != ENOENT)
{
char err[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to remove persisted server configuration '%s': %d, %s",
filename, errno, strerror_r(errno, err, sizeof(err)));
filename, errno, mxs_strerror(errno));
}
else
{
@ -542,9 +541,8 @@ bool runtime_destroy_listener(SERVICE *service, const char *name)
{
if (errno != ENOENT)
{
char err[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to remove persisted listener configuration '%s': %d, %s",
filename, errno, strerror_r(errno, err, sizeof(err)));
filename, errno, mxs_strerror(errno));
}
else
{
@ -618,9 +616,8 @@ bool runtime_destroy_monitor(MXS_MONITOR *monitor)
{
if (errno != ENOENT)
{
char err[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to remove persisted monitor configuration '%s': %d, %s",
filename, errno, strerror_r(errno, err, sizeof(err)));
filename, errno, mxs_strerror(errno));
}
else
{

49
server/core/dcb.c
View File

@ -537,14 +537,13 @@ dcb_process_victim_queue(int threadid)
{
int eno = errno;
errno = 0;
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("%lu [dcb_process_victim_queue] Error : Failed to close "
"socket %d on dcb %p due error %d, %s.",
pthread_self(),
dcb->fd,
dcb,
eno,
strerror_r(eno, errbuf, sizeof(errbuf)));
mxs_strerror(eno));
}
else
{
@ -868,7 +867,6 @@ dcb_bytes_readable(DCB *dcb)
if (-1 == ioctl(dcb->fd, FIONREAD, &bytesavailable))
{
char errbuf[MXS_STRERROR_BUFLEN];
/* <editor-fold defaultstate="collapsed" desc=" Error Logging "> */
MXS_ERROR("%lu [dcb_read] Error : ioctl FIONREAD for dcb %p in "
"state %s fd %d failed due error %d, %s.",
@ -877,7 +875,7 @@ dcb_bytes_readable(DCB *dcb)
STRDCBSTATE(dcb->state),
dcb->fd,
errno,
strerror_r(errno, errbuf, sizeof(errbuf)));
mxs_strerror(errno));
/* </editor-fold> */
return -1;
}
@ -946,7 +944,6 @@ dcb_basic_read(DCB *dcb, int bytesavailable, int maxbytes, int nreadtotal, int *
* This is a fatal error which should cause shutdown.
* Todo shutdown if memory allocation fails.
*/
char errbuf[MXS_STRERROR_BUFLEN];
/* <editor-fold defaultstate="collapsed" desc=" Error Logging "> */
MXS_ERROR("%lu [dcb_read] Error : Failed to allocate read buffer "
"for dcb %p fd %d, due %d, %s.",
@ -954,7 +951,7 @@ dcb_basic_read(DCB *dcb, int bytesavailable, int maxbytes, int nreadtotal, int *
dcb,
dcb->fd,
errno,
strerror_r(errno, errbuf, sizeof(errbuf)));
mxs_strerror(errno));
/* </editor-fold> */
*nsingleread = -1;
}
@ -967,7 +964,6 @@ dcb_basic_read(DCB *dcb, int bytesavailable, int maxbytes, int nreadtotal, int *
{
if (errno != 0 && errno != EAGAIN && errno != EWOULDBLOCK)
{
char errbuf[MXS_STRERROR_BUFLEN];
/* <editor-fold defaultstate="collapsed" desc=" Error Logging "> */
MXS_ERROR("%lu [dcb_read] Error : Read failed, dcb %p in state "
"%s fd %d, due %d, %s.",
@ -976,7 +972,7 @@ dcb_basic_read(DCB *dcb, int bytesavailable, int maxbytes, int nreadtotal, int *
STRDCBSTATE(dcb->state),
dcb->fd,
errno,
strerror_r(errno, errbuf, sizeof(errbuf)));
mxs_strerror(errno));
/* </editor-fold> */
}
gwbuf_free(buffer);
@ -1076,7 +1072,6 @@ dcb_basic_read_SSL(DCB *dcb, int *nsingleread)
* This is a fatal error which should cause shutdown.
* Todo shutdown if memory allocation fails.
*/
char errbuf[MXS_STRERROR_BUFLEN];
/* <editor-fold defaultstate="collapsed" desc=" Error Logging "> */
MXS_ERROR("%lu [dcb_read] Error : Failed to allocate read buffer "
"for dcb %p fd %d, due %d, %s.",
@ -1084,7 +1079,7 @@ dcb_basic_read_SSL(DCB *dcb, int *nsingleread)
dcb,
dcb->fd,
errno,
strerror_r(errno, errbuf, sizeof(errbuf)));
mxs_strerror(errno));
/* </editor-fold> */
*nsingleread = -1;
return NULL;
@ -1175,9 +1170,7 @@ dcb_log_errors_SSL (DCB *dcb, const char *called_by, int ret)
{
int local_errno = errno;
MXS_ERROR("SSL error caused by TCP error %d %s",
local_errno,
strerror_r(local_errno, errbuf, sizeof(errbuf))
);
local_errno, mxs_strerror(local_errno));
}
else
{
@ -1278,7 +1271,6 @@ dcb_log_write_failure(DCB *dcb, GWBUF *queue, int eno)
{
if (eno == EPIPE)
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_DEBUG("%lu [dcb_write] Write to dcb "
"%p in state %s fd %d failed "
"due errno %d, %s",
@ -1287,7 +1279,7 @@ dcb_log_write_failure(DCB *dcb, GWBUF *queue, int eno)
STRDCBSTATE(dcb->state),
dcb->fd,
eno,
strerror_r(eno, errbuf, sizeof(errbuf)));
mxs_strerror(eno));
}
}
@ -1297,7 +1289,6 @@ dcb_log_write_failure(DCB *dcb, GWBUF *queue, int eno)
eno != EAGAIN &&
eno != EWOULDBLOCK)
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("Write to dcb %p in "
"state %s fd %d failed due "
"errno %d, %s",
@ -1305,7 +1296,7 @@ dcb_log_write_failure(DCB *dcb, GWBUF *queue, int eno)
STRDCBSTATE(dcb->state),
dcb->fd,
eno,
strerror_r(eno, errbuf, sizeof(errbuf)));
mxs_strerror(eno));
}
@ -1331,12 +1322,11 @@ dcb_log_write_failure(DCB *dcb, GWBUF *queue, int eno)
}
if (dolog)
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_DEBUG("%lu [dcb_write] Writing to %s socket failed due %d, %s.",
pthread_self(),
DCB_ROLE_CLIENT_HANDLER == dcb->dcb_role ? "client" : "backend server",
eno,
strerror_r(eno, errbuf, sizeof(errbuf)));
mxs_strerror(eno));
}
}
}
@ -2097,13 +2087,12 @@ gw_write(DCB *dcb, GWBUF *writeq, bool *stop_writing)
saved_errno != EPIPE)
#endif
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("Write to %s %s in state %s failed due errno %d, %s",
DCB_STRTYPE(dcb), dcb->remote, STRDCBSTATE(dcb->state),
saved_errno, strerror_r(saved_errno, errbuf, sizeof(errbuf)));
saved_errno, mxs_strerror(saved_errno));
MXS_DEBUG("Write to %s %s in state %s failed due errno %d, %s (at %p, fd %d)",
DCB_STRTYPE(dcb), dcb->remote, STRDCBSTATE(dcb->state),
saved_errno, strerror_r(saved_errno, errbuf, sizeof(errbuf)),
saved_errno, mxs_strerror(saved_errno),
dcb, dcb->fd);
}
}
@ -2677,7 +2666,6 @@ dcb_accept(DCB *listener)
int sendbuf;
struct sockaddr_storage client_conn;
socklen_t optlen = sizeof(sendbuf);
char errbuf[MXS_STRERROR_BUFLEN];
if ((c_sock = dcb_accept_one_connection(listener, (struct sockaddr *)&client_conn)) >= 0)
{
@ -2691,7 +2679,7 @@ dcb_accept(DCB *listener)
if (setsockopt(c_sock, SOL_SOCKET, SO_SNDBUF, &sendbuf, optlen) != 0)
{
MXS_ERROR("Failed to set socket options. Error %d: %s",
errno, strerror_r(errno, errbuf, sizeof(errbuf)));
errno, mxs_strerror(errno));
}
sendbuf = MXS_CLIENT_SO_RCVBUF;
@ -2699,7 +2687,7 @@ dcb_accept(DCB *listener)
if (setsockopt(c_sock, SOL_SOCKET, SO_RCVBUF, &sendbuf, optlen) != 0)
{
MXS_ERROR("Failed to set socket options. Error %d: %s",
errno, strerror_r(errno, errbuf, sizeof(errbuf)));
errno, mxs_strerror(errno));
}
setnonblocking(c_sock);
@ -2826,7 +2814,6 @@ dcb_accept_one_connection(DCB *listener, struct sockaddr *client_conn)
if (c_sock == -1)
{
char errbuf[MXS_STRERROR_BUFLEN];
/* Did not get a file descriptor */
if (eno == EAGAIN || eno == EWOULDBLOCK)
{
@ -2848,14 +2835,14 @@ dcb_accept_one_connection(DCB *listener, struct sockaddr *client_conn)
MXS_DEBUG("%lu [dcb_accept_one_connection] Error %d, %s. ",
pthread_self(),
eno,
strerror_r(eno, errbuf, sizeof(errbuf)));
mxs_strerror(eno));
/* Log an error the first time this happens */
if (i == 0)
{
MXS_ERROR("Error %d, %s. Failed to accept new client connection.",
eno,
strerror_r(eno, errbuf, sizeof(errbuf)));
mxs_strerror(eno));
}
nanosecs = (long long)1000000 * 100 * i * i;
ts1.tv_sec = nanosecs / 1000000000;
@ -2871,7 +2858,7 @@ dcb_accept_one_connection(DCB *listener, struct sockaddr *client_conn)
*/
MXS_ERROR("Failed to accept new client connection due to %d, %s.",
eno,
strerror_r(eno, errbuf, sizeof(errbuf)));
mxs_strerror(eno));
break;
}
}
@ -3117,10 +3104,8 @@ dcb_set_socket_option(int sockfd, int level, int optname, void *optval, socklen_
{
if (setsockopt(sockfd, level, optname, optval, optlen) != 0)
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to set socket options. Error %d: %s",
errno,
strerror_r(errno, errbuf, sizeof(errbuf)));
errno, mxs_strerror(errno));
return -1;
}
return 0;

3
server/core/externcmd.c
View File

@ -179,9 +179,8 @@ int externcmd_execute(EXTERNCMD* cmd)
if (pid < 0)
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to execute command '%s', fork failed: [%d] %s",
cmd->argv[0], errno, strerror_r(errno, errbuf, sizeof(errbuf)));
cmd->argv[0], errno, mxs_strerror(errno));
rval = -1;
}
else if (pid == 0)

50
server/core/gateway.cc
View File

@ -349,9 +349,8 @@ sigchld_handler (int i)
if ((child = wait(&exit_status)) == -1)
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to wait child process: %d %s",
errno, strerror_r(errno, errbuf, sizeof(errbuf)));
errno, mxs_strerror(errno));
}
else
{
@ -464,11 +463,10 @@ static int signal_set(int sig, void (*handler)(int))
if (err < 0)
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed call sigaction() in %s due to %d, %s.",
program_invocation_short_name,
errno,
strerror_r(errno, errbuf, sizeof(errbuf)));
mxs_strerror(errno));
rc = 1;
}
@ -500,9 +498,8 @@ static bool create_datadir(const char* base, char* datadir)
}
else
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("Cannot create data directory '%s': %d %s\n",
datadir, errno, strerror_r(errno, errbuf, sizeof(errbuf)));
datadir, errno, mxs_strerror(errno));
}
}
}
@ -510,9 +507,8 @@ static bool create_datadir(const char* base, char* datadir)
{
if (len < PATH_MAX)
{
char errbuf[MXS_STRERROR_BUFLEN];
fprintf(stderr, "Error: Cannot create data directory '%s': %d %s\n",
datadir, errno, strerror_r(errno, errbuf, sizeof(errbuf)));
datadir, errno, mxs_strerror(errno));
}
else
{
@ -538,9 +534,8 @@ int ntfw_cb(const char* filename,
{
int eno = errno;
errno = 0;
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to remove the data directory %s of MaxScale due to %d, %s.",
datadir, eno, strerror_r(eno, errbuf, sizeof(errbuf)));
datadir, eno, mxs_strerror(eno));
}
return rc;
}
@ -730,22 +725,20 @@ static void print_log_n_stderr(
{
if (mxs_log_init(NULL, get_logdir(), MXS_LOG_TARGET_FS))
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("%s%s%s%s",
logstr,
eno == 0 ? "" : " (",
eno == 0 ? "" : strerror_r(eno, errbuf, sizeof(errbuf)),
eno == 0 ? "" : mxs_strerror(eno),
eno == 0 ? "" : ")");
}
}
if (do_stderr)
{
char errbuf[MXS_STRERROR_BUFLEN];
fprintf(stderr,
"* Error: %s%s%s%s\n",
fprstr,
eno == 0 ? "" : " (",
eno == 0 ? "" : strerror_r(eno, errbuf, sizeof(errbuf)),
eno == 0 ? "" : mxs_strerror(eno),
eno == 0 ? "" : ")");
}
}
@ -1807,9 +1800,8 @@ int main(int argc, char **argv)
}
else
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("Cannot create data directory '%s': %d %s\n",
datadir, errno, strerror_r(errno, errbuf, sizeof(errbuf)));
datadir, errno, mxs_strerror(errno));
goto return_main;
}
@ -2126,12 +2118,11 @@ static void unlink_pidfile(void)
{
if (unlink(pidfile))
{
char errbuf[MXS_STRERROR_BUFLEN];
fprintf(stderr,
"MaxScale failed to remove pidfile %s: error %d, %s\n",
pidfile,
errno,
strerror_r(errno, errbuf, sizeof(errbuf)));
mxs_strerror(errno));
}
}
}
@ -2587,36 +2578,32 @@ static int set_user(const char* user)
pwname = getpwnam(user);
if (pwname == NULL)
{
char errbuf[MXS_STRERROR_BUFLEN];
printf("Error: Failed to retrieve user information for '%s': %d %s\n",
user, errno, errno == 0 ? "User not found" : strerror_r(errno, errbuf, sizeof(errbuf)));
user, errno, errno == 0 ? "User not found" : mxs_strerror(errno));
return -1;
}
rval = setgid(pwname->pw_gid);
if (rval != 0)
{
char errbuf[MXS_STRERROR_BUFLEN];
printf("Error: Failed to change group to '%d': %d %s\n",
pwname->pw_gid, errno, strerror_r(errno, errbuf, sizeof(errbuf)));
pwname->pw_gid, errno, mxs_strerror(errno));
return rval;
}
rval = setuid(pwname->pw_uid);
if (rval != 0)
{
char errbuf[MXS_STRERROR_BUFLEN];
printf("Error: Failed to change user to '%s': %d %s\n",
pwname->pw_name, errno, strerror_r(errno, errbuf, sizeof(errbuf)));
pwname->pw_name, errno, mxs_strerror(errno));
return rval;
}
if (prctl(PR_GET_DUMPABLE) == 0)
{
if (prctl(PR_SET_DUMPABLE , 1) == -1)
{
char errbuf[MXS_STRERROR_BUFLEN];
printf("Error: Failed to set dumpable flag on for the process '%s': %d %s\n",
pwname->pw_name, errno, strerror_r(errno, errbuf, sizeof(errbuf)));
pwname->pw_name, errno, mxs_strerror(errno));
return -1;
}
}
@ -2660,14 +2647,13 @@ static bool change_cwd()
if (chdir(get_logdir()) != 0)
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to change working directory to '%s': %d, %s. "
"Trying to change working directory to '/'.",
get_logdir(), errno, strerror_r(errno, errbuf, sizeof (errbuf)));
get_logdir(), errno, mxs_strerror(errno));
if (chdir("/") != 0)
{
MXS_ERROR("Failed to change working directory to '/': %d, %s",
errno, strerror_r(errno, errbuf, sizeof (errbuf)));
errno, mxs_strerror(errno));
rval = false;
}
else
@ -2719,8 +2705,7 @@ static bool daemonize(void)
if (pid < 0)
{
char errbuf[MXS_STRERROR_BUFLEN];
fprintf(stderr, "fork() error %s\n", strerror_r(errno, errbuf, sizeof(errbuf)));
fprintf(stderr, "fork() error %s\n", mxs_strerror(errno));
exit(1);
}
@ -2732,8 +2717,7 @@ static bool daemonize(void)
if (setsid() < 0)
{
char errbuf[MXS_STRERROR_BUFLEN];
fprintf(stderr, "setsid() error %s\n", strerror_r(errno, errbuf, sizeof(errbuf)));
fprintf(stderr, "setsid() error %s\n", mxs_strerror(errno));
exit(1);
}
return false;

6
server/core/hashtable.c
View File

@ -746,9 +746,8 @@ hashtable_save(HASHTABLE *table, const char *filename,
}
if (write(fd, &rval, sizeof(rval)) == -1) // Write zero counter, will be overrwriten at end
{
char err[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to write hashtable item count: %d, %s", errno,
strerror_r(errno, err, sizeof(err)));
mxs_strerror(errno));
}
if ((iter = hashtable_iterator(table)) != NULL)
{
@ -776,9 +775,8 @@ hashtable_save(HASHTABLE *table, const char *filename,
{
if (write(fd, &rval, sizeof(rval)) == -1)
{
char err[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to write hashtable item count: %d, %s", errno,
strerror_r(errno, err, sizeof(err)));
mxs_strerror(errno));
}
}

9
server/core/listener.c
View File

@ -399,9 +399,8 @@ static bool create_listener_config(const SERV_LISTENER *listener, const char *fi
if (file == -1)
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to open file '%s' when serializing listener '%s': %d, %s",
filename, listener->name, errno, strerror_r(errno, errbuf, sizeof(errbuf)));
filename, listener->name, errno, mxs_strerror(errno));
return false;
}
@ -487,9 +486,8 @@ bool listener_serialize(const SERV_LISTENER *listener)
if (unlink(filename) == -1 && errno != ENOENT)
{
char err[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to remove temporary listener configuration at '%s': %d, %s",
filename, errno, strerror_r(errno, err, sizeof(err)));
filename, errno, mxs_strerror(errno));
}
else if (create_listener_config(listener, filename))
{
@ -506,9 +504,8 @@ bool listener_serialize(const SERV_LISTENER *listener)
}
else
{
char err[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to rename temporary listener configuration at '%s': %d, %s",
filename, errno, strerror_r(errno, err, sizeof(err)));
filename, errno, mxs_strerror(errno));
}
}

18
server/core/log_manager.cc
View File

@ -1608,9 +1608,8 @@ static bool logfile_write_header(skygw_file_t* file)
if ((header_items != 1) || (line_items != 1))
{
char errbuf[MXS_STRERROR_BUFLEN];
LOG_ERROR("MaxScale Log: Writing header failed due to %d, %s\n",
errno, strerror_r(errno, errbuf, sizeof(errbuf)));
errno, mxs_strerror(errno));
written = false;
}
@ -1785,15 +1784,13 @@ static bool check_file_and_path(const char* filename, bool* writable)
{
if (file_is_symlink(filename))
{
char errbuf[MXS_STRERROR_BUFLEN];
LOG_ERROR("MaxScale Log: Error, Can't access file pointed to by %s due to %d, %s.\n",
filename, errno, strerror_r(errno, errbuf, sizeof(errbuf)));
filename, errno, mxs_strerror(errno));
}
else
{
char errbuf[MXS_STRERROR_BUFLEN];
LOG_ERROR("MaxScale Log: Error, Can't access %s due to %d, %s.\n",
filename, errno, strerror_r(errno, errbuf, sizeof(errbuf)));
filename, errno, mxs_strerror(errno));
}
if (writable)
@ -1890,9 +1887,8 @@ static bool logfile_init(logfile_t* logfile,
if (mkdir(dir, S_IRWXU | S_IRWXG) != 0 && (errno != EEXIST))
{
char errbuf[MXS_STRERROR_BUFLEN];
LOG_ERROR("MaxScale Log: Error, creating directory %s failed due to %d, %s.\n",
dir, errno, strerror_r(errno, errbuf, sizeof(errbuf)));
dir, errno, mxs_strerror(errno));
succ = false;
goto return_with_succ;
@ -2075,9 +2071,8 @@ static bool logfile_write_footer(skygw_file_t* file, const char* suffix)
if ((header_items != 1) || (line_items != 1))
{
char errbuf[MXS_STRERROR_BUFLEN];
LOG_ERROR("MaxScale Log: Writing footer failed due to %d, %s\n",
errno, strerror_r(errno, errbuf, sizeof(errbuf)));
errno, mxs_strerror(errno));
written = false;
}
@ -2203,10 +2198,9 @@ static bool thr_flush_file(logmanager_t *lm, filewriter_t *fwr)
if (err)
{
// TODO: Log this to syslog.
char errbuf[MXS_STRERROR_BUFLEN];
LOG_ERROR("MaxScale Log: Error, writing to the log-file %s failed due to %d, %s. "
"Disabling writing to the log.\n",
lf->lf_full_file_name, err, strerror_r(err, errbuf, sizeof(errbuf)));
lf->lf_full_file_name, err, mxs_strerror(err));
mxs_log_set_maxlog_enabled(false);
}

18
server/core/monitor.c
View File

@ -1276,9 +1276,8 @@ static bool create_monitor_server_config(const MXS_MONITOR *monitor, const char
if (file == -1)
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to open file '%s' when serializing monitor '%s': %d, %s",
filename, monitor->name, errno, strerror_r(errno, errbuf, sizeof(errbuf)));
filename, monitor->name, errno, mxs_strerror(errno));
return false;
}
@ -1315,9 +1314,8 @@ static bool create_monitor_config(const MXS_MONITOR *monitor, const char *filena
if (file == -1)
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to open file '%s' when serializing monitor '%s': %d, %s",
filename, monitor->name, errno, strerror_r(errno, errbuf, sizeof(errbuf)));
filename, monitor->name, errno, mxs_strerror(errno));
return false;
}
@ -1350,9 +1348,8 @@ bool monitor_serialize_servers(const MXS_MONITOR *monitor)
if (unlink(filename) == -1 && errno != ENOENT)
{
char err[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to remove temporary monitor configuration at '%s': %d, %s",
filename, errno, strerror_r(errno, err, sizeof(err)));
filename, errno, mxs_strerror(errno));
}
else if (create_monitor_server_config(monitor, filename))
{
@ -1369,9 +1366,8 @@ bool monitor_serialize_servers(const MXS_MONITOR *monitor)
}
else
{
char err[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to rename temporary monitor configuration at '%s': %d, %s",
filename, errno, strerror_r(errno, err, sizeof(err)));
filename, errno, mxs_strerror(errno));
}
}
@ -1387,9 +1383,8 @@ bool monitor_serialize(const MXS_MONITOR *monitor)
if (unlink(filename) == -1 && errno != ENOENT)
{
char err[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to remove temporary monitor configuration at '%s': %d, %s",
filename, errno, strerror_r(errno, err, sizeof(err)));
filename, errno, mxs_strerror(errno));
}
else if (create_monitor_config(monitor, filename))
{
@ -1406,9 +1401,8 @@ bool monitor_serialize(const MXS_MONITOR *monitor)
}
else
{
char err[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to rename temporary monitor configuration at '%s': %d, %s",
filename, errno, strerror_r(errno, err, sizeof(err)));
filename, errno, mxs_strerror(errno));
}
}

15
server/core/poll.c
View File

@ -239,9 +239,8 @@ poll_init()
{
if ((epoll_fd[i] = epoll_create(MAX_EVENTS)) == -1)
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("FATAL: Could not create epoll instance: %s",
strerror_r(errno, errbuf, sizeof(errbuf)));
mxs_strerror(errno));
exit(-1);
}
}
@ -930,13 +929,12 @@ process_pollq(int thread_id, struct epoll_event *event)
}
else
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_DEBUG("%lu [poll_waitevents] "
"EPOLLOUT due %d, %s. "
"dcb %p, fd %i",
pthread_self(),
eno,
strerror_r(eno, errbuf, sizeof(errbuf)),
mxs_strerror(eno),
dcb,
dcb->fd);
}
@ -988,12 +986,11 @@ process_pollq(int thread_id, struct epoll_event *event)
int eno = gw_getsockerrno(dcb->fd);
if (eno != 0)
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_DEBUG("%lu [poll_waitevents] "
"EPOLLERR due %d, %s.",
pthread_self(),
eno,
strerror_r(eno, errbuf, sizeof(errbuf)));
mxs_strerror(eno));
}
ts_stats_increment(pollStats.n_error, thread_id);
@ -1006,7 +1003,6 @@ process_pollq(int thread_id, struct epoll_event *event)
if (ev & EPOLLHUP)
{
ss_debug(int eno = gw_getsockerrno(dcb->fd));
ss_debug(char errbuf[MXS_STRERROR_BUFLEN]);
MXS_DEBUG("%lu [poll_waitevents] "
"EPOLLHUP on dcb %p, fd %d. "
"Errno %d, %s.",
@ -1014,7 +1010,7 @@ process_pollq(int thread_id, struct epoll_event *event)
dcb,
dcb->fd,
eno,
strerror_r(eno, errbuf, sizeof(errbuf)));
mxs_strerror(eno));
ts_stats_increment(pollStats.n_hup, thread_id);
if ((dcb->flags & DCBF_HUNG) == 0)
{
@ -1031,7 +1027,6 @@ process_pollq(int thread_id, struct epoll_event *event)
if (ev & EPOLLRDHUP)
{
ss_debug(int eno = gw_getsockerrno(dcb->fd));
ss_debug(char errbuf[MXS_STRERROR_BUFLEN]);
MXS_DEBUG("%lu [poll_waitevents] "
"EPOLLRDHUP on dcb %p, fd %d. "
"Errno %d, %s.",
@ -1039,7 +1034,7 @@ process_pollq(int thread_id, struct epoll_event *event)
dcb,
dcb->fd,
eno,
strerror_r(eno, errbuf, sizeof(errbuf)));
mxs_strerror(eno));
ts_stats_increment(pollStats.n_hup, thread_id);
if ((dcb->flags & DCBF_HUNG) == 0)

39
server/core/secrets.c
View File

@ -93,9 +93,8 @@ secrets_readKeys(const char* path)
}
else
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("The provided path \"%s\" does not exist or cannot be accessed. "
"Error: %d, %s.", path, errno, strerror_r(errno, errbuf, sizeof(errbuf)));
"Error: %d, %s.", path, errno, mxs_strerror(errno));
return NULL;
}
@ -115,22 +114,20 @@ secrets_readKeys(const char* path)
{
if (!reported)
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_NOTICE("Encrypted password file %s can't be accessed "
"(%s). Password encryption is not used.",
secret_file,
strerror_r(eno, errbuf, sizeof(errbuf)));
mxs_strerror(eno));
reported = 1;
}
}
else
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("Access for secrets file "
"[%s] failed. Error %d, %s.",
secret_file,
eno,
strerror_r(eno, errbuf, sizeof(errbuf)));
mxs_strerror(eno));
}
return NULL;
}
@ -141,12 +138,11 @@ secrets_readKeys(const char* path)
{
int eno = errno;
errno = 0;
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed opening secret "
"file [%s]. Error %d, %s.",
secret_file,
eno,
strerror_r(eno, errbuf, sizeof(errbuf)));
mxs_strerror(eno));
return NULL;
}
@ -157,12 +153,11 @@ secrets_readKeys(const char* path)
int eno = errno;
errno = 0;
close(fd);
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("fstat for secret file %s "
"failed. Error %d, %s.",
secret_file,
eno,
strerror_r(eno, errbuf, sizeof(errbuf)));
mxs_strerror(eno));
return NULL;
}
@ -171,12 +166,11 @@ secrets_readKeys(const char* path)
int eno = errno;
errno = 0;
close(fd);
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("Secrets file %s has "
"incorrect size. Error %d, %s.",
secret_file,
eno,
strerror_r(eno, errbuf, sizeof(errbuf)));
mxs_strerror(eno));
return NULL;
}
if (secret_stats.st_mode != (S_IRUSR | S_IFREG))
@ -206,14 +200,13 @@ secrets_readKeys(const char* path)
errno = 0;
close(fd);
MXS_FREE(keys);
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("Read from secrets file "
"%s failed. Read %ld, expected %d bytes. Error %d, %s.",
secret_file,
len,
(int)sizeof(MAXKEYS),
eno,
strerror_r(eno, errbuf, sizeof(errbuf)));
mxs_strerror(eno));
return NULL;
}
@ -223,12 +216,11 @@ secrets_readKeys(const char* path)
int eno = errno;
errno = 0;
MXS_FREE(keys);
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed closing the "
"secrets file %s. Error %d, %s.",
secret_file,
eno,
strerror_r(eno, errbuf, sizeof(errbuf)));
mxs_strerror(eno));
return NULL;
}
ss_dassert(keys != NULL);
@ -271,22 +263,20 @@ int secrets_write_keys(const char *dir)
/* Open for writing | Create | Truncate the file for writing */
if ((fd = open(secret_file, O_CREAT | O_WRONLY | O_TRUNC, S_IRUSR)) < 0)
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("failed opening secret "
"file [%s]. Error %d, %s.",
secret_file,
errno,
strerror_r(errno, errbuf, sizeof(errbuf)));
mxs_strerror(errno));
return 1;
}
/* Open for writing | Create | Truncate the file for writing */
if ((randfd = open("/dev/random", O_RDONLY)) < 0)
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("failed opening /dev/random. Error %d, %s.",
errno,
strerror_r(errno, errbuf, sizeof(errbuf)));
mxs_strerror(errno));
close(fd);
return 1;
}
@ -306,12 +296,11 @@ int secrets_write_keys(const char *dir)
/* Write data */
if (write(fd, &key, sizeof(key)) < 0)
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("failed writing into "
"secret file [%s]. Error %d, %s.",
secret_file,
errno,
strerror_r(errno, errbuf, sizeof(errbuf)));
mxs_strerror(errno));
close(fd);
return 1;
}
@ -319,22 +308,20 @@ int secrets_write_keys(const char *dir)
/* close file */
if (close(fd) < 0)
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("failed closing the "
"secret file [%s]. Error %d, %s.",
secret_file,
errno,
strerror_r(errno, errbuf, sizeof(errbuf)));
mxs_strerror(errno));
}
if (chmod(secret_file, S_IRUSR) < 0)
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("failed to change the permissions of the"
"secret file [%s]. Error %d, %s.",
secret_file,
errno,
strerror_r(errno, errbuf, sizeof(errbuf)));
mxs_strerror(errno));
}
return 0;

9
server/core/server.c
View File

@ -1119,9 +1119,8 @@ static bool create_server_config(const SERVER *server, const char *filename)
if (file == -1)
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to open file '%s' when serializing server '%s': %d, %s",
filename, server->unique_name, errno, strerror_r(errno, errbuf, sizeof(errbuf)));
filename, server->unique_name, errno, mxs_strerror(errno));
return false;
}
@ -1230,9 +1229,8 @@ bool server_serialize(const SERVER *server)
if (unlink(filename) == -1 && errno != ENOENT)
{
char err[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to remove temporary server configuration at '%s': %d, %s",
filename, errno, strerror_r(errno, err, sizeof(err)));
filename, errno, mxs_strerror(errno));
}
else if (create_server_config(server, filename))
{
@ -1249,9 +1247,8 @@ bool server_serialize(const SERVER *server)
}
else
{
char err[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to rename temporary server configuration at '%s': %d, %s",
filename, errno, strerror_r(errno, err, sizeof(err)));
filename, errno, mxs_strerror(errno));
}
}

9
server/core/service.c
View File

@ -2217,9 +2217,8 @@ static bool create_service_config(const SERVICE *service, const char *filename)
if (file == -1)
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to open file '%s' when serializing service '%s': %d, %s",
filename, service->name, errno, strerror_r(errno, errbuf, sizeof(errbuf)));
filename, service->name, errno, mxs_strerror(errno));
return false;
}
@ -2258,9 +2257,8 @@ bool service_serialize_servers(const SERVICE *service)
if (unlink(filename) == -1 && errno != ENOENT)
{
char err[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to remove temporary service configuration at '%s': %d, %s",
filename, errno, strerror_r(errno, err, sizeof(err)));
filename, errno, mxs_strerror(errno));
}
else if (create_service_config(service, filename))
{
@ -2277,9 +2275,8 @@ bool service_serialize_servers(const SERVICE *service)
}
else
{
char err[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to rename temporary service configuration at '%s': %d, %s",
filename, errno, strerror_r(errno, err, sizeof(err)));
filename, errno, mxs_strerror(errno));
}
}

78
server/core/skygw_utils.cc
View File

@ -56,10 +56,9 @@ int skygw_rwlock_rdlock(skygw_rwlock_t* rwlock)
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)));
mxs_strerror(err));
}
return err;
}
@ -75,10 +74,9 @@ int skygw_rwlock_wrlock(skygw_rwlock_t* rwlock)
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)));
mxs_strerror(err));
}
return err;
}
@ -93,9 +91,8 @@ int skygw_rwlock_unlock(skygw_rwlock_t* rwlock)
}
else
{
char errbuf[MXS_STRERROR_BUFLEN];
ss_dfprintf(stderr, "* pthread_rwlock_unlock : %s\n",
strerror_r(err, errbuf, sizeof (errbuf)));
mxs_strerror(err));
}
return err;
}
@ -106,9 +103,8 @@ int skygw_rwlock_destroy(skygw_rwlock_t* rwlock)
/** 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)));
err, mxs_strerror(err));
goto retblock;
}
/** Clean the struct */
@ -118,9 +114,8 @@ int skygw_rwlock_destroy(skygw_rwlock_t* 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)));
err, mxs_strerror(err));
}
else
{
@ -150,9 +145,8 @@ int skygw_rwlock_init(skygw_rwlock_t** rwlock)
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)));
mxs_strerror(err));
goto return_err;
}
*rwlock = rwl;
@ -348,9 +342,8 @@ int skygw_thread_start(skygw_thread_t* thr)
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)));
err, mxs_strerror(errno));
goto return_err;
}
@ -524,9 +517,8 @@ simple_mutex_t* simple_mutex_init(simple_mutex_t* mutexptr, const char* name)
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)));
name, err, mxs_strerror(errno));
perror("simple_mutex : ");
/** Write zeroes if flat, free otherwise. */
@ -564,9 +556,8 @@ int simple_mutex_done(simple_mutex_t* sm)
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)));
sm->sm_name, err, mxs_strerror(errno));
goto return_err;
}
#endif
@ -611,9 +602,8 @@ int simple_mutex_lock(simple_mutex_t* sm, bool block)
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)));
sm->sm_name, err, mxs_strerror(errno));
perror("simple_mutex : ");
}
else
@ -640,9 +630,8 @@ int simple_mutex_unlock(simple_mutex_t* sm)
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)));
sm->sm_name, err, mxs_strerror(errno));
perror("simple_mutex : ");
}
else
@ -674,9 +663,8 @@ skygw_message_t* skygw_message_init(void)
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)));
err, mxs_strerror(errno));
free(mes);
mes = NULL;
goto return_mes;
@ -685,9 +673,8 @@ skygw_message_t* skygw_message_init(void)
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)));
err, mxs_strerror(errno));
pthread_mutex_destroy(&mes->mes_mutex);
free(mes);
mes = NULL;
@ -714,18 +701,16 @@ void skygw_message_done(skygw_message_t* mes)
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)));
err, mxs_strerror(errno));
}
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)));
err, mxs_strerror(errno));
}
ss_dassert(err == 0);
free(mes);
@ -741,9 +726,8 @@ skygw_mes_rc_t skygw_message_send(skygw_message_t* mes)
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)));
err, mxs_strerror(errno));
goto return_mes_rc;
}
mes->mes_sent = true;
@ -755,17 +739,15 @@ skygw_mes_rc_t skygw_message_send(skygw_message_t* mes)
}
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, mxs_strerror(errno));
}
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)));
err, mxs_strerror(errno));
}
return_mes_rc:
@ -781,9 +763,8 @@ void skygw_message_wait(skygw_message_t* mes)
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)));
err, mxs_strerror(errno));
}
ss_dassert(err == 0);
@ -793,9 +774,8 @@ void skygw_message_wait(skygw_message_t* mes)
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)));
err, mxs_strerror(errno));
}
}
mes->mes_sent = false;
@ -803,9 +783,8 @@ void skygw_message_wait(skygw_message_t* mes)
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)));
err, mxs_strerror(errno));
}
ss_dassert(err == 0);
}
@ -819,9 +798,8 @@ void skygw_message_reset(skygw_message_t* mes)
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)));
err, mxs_strerror(errno));
goto return_mes_rc;
}
ss_dassert(err == 0);
@ -830,9 +808,8 @@ void skygw_message_reset(skygw_message_t* mes)
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)));
err, mxs_strerror(errno));
goto return_mes_rc;
}
return_mes_rc:
@ -932,9 +909,8 @@ skygw_file_t* skygw_file_init(const char* fname,
{
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)));
file->sf_fname, eno, mxs_strerror(eno));
free(file);
file = NULL;
goto return_file;
@ -956,9 +932,8 @@ skygw_file_t* skygw_file_init(const char* fname,
{
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)));
fname, symlinkname, eno, mxs_strerror(eno));
free(file);
file = NULL;
goto return_file;
@ -992,9 +967,8 @@ void skygw_file_close(skygw_file_t* file)
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)));
file->sf_fname, errno, mxs_strerror(errno));
}
else
{

18
server/core/utils.c
View File

@ -102,21 +102,19 @@ int setnonblocking(int fd)
if ((fl = fcntl(fd, F_GETFL, 0)) == -1)
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("Can't GET fcntl for %i, errno = %d, %s.",
fd,
errno,
strerror_r(errno, errbuf, sizeof(errbuf)));
mxs_strerror(errno));
return 1;
}
if (fcntl(fd, F_SETFL, fl | O_NONBLOCK) == -1)
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("Can't SET fcntl for %i, errno = %d, %s",
fd,
errno,
strerror_r(errno, errbuf, sizeof(errbuf)));
mxs_strerror(errno));
return 1;
}
return 0;
@ -391,18 +389,16 @@ static bool mkdir_all_internal(char *path, mode_t mask)
}
else
{
char err[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to create directory '%s': %d, %s",
path, errno, strerror_r(errno, err, sizeof(err)));
path, errno, mxs_strerror(errno));
}
}
}
}
else
{
char err[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to create directory '%s': %d, %s",
path, errno, strerror_r(errno, err, sizeof(err)));
path, errno, mxs_strerror(errno));
}
}
else
@ -711,9 +707,8 @@ char* replace_literal(char* haystack, const char* needle, const char* replacemen
if (search_re == NULL)
{
char errbuf[MXS_STRERROR_BUFLEN];
fprintf(stderr, "Regex memory allocation failed : %s\n",
strerror_r(errno, errbuf, sizeof (errbuf)));
mxs_strerror(errno));
newstr = haystack;
goto retblock;
}
@ -724,9 +719,8 @@ char* replace_literal(char* haystack, const char* needle, const char* replacemen
if (newstr == NULL)
{
char errbuf[MXS_STRERROR_BUFLEN];
fprintf(stderr, "Regex memory allocation failed : %s\n",
strerror_r(errno, errbuf, sizeof (errbuf)));
mxs_strerror(errno));
free(search_re);
free(newstr);
newstr = haystack;

6
server/modules/authenticator/CDCPlainAuth/cdc_plain_auth.c
View File

@ -114,8 +114,7 @@ static bool cdc_add_new_user(const MODULECMD_ARG *args)
}
else
{
char err[MXS_STRERROR_BUFLEN];
char *real_err = strerror_r(errno, err, sizeof(err));
const char *real_err = mxs_strerror(errno);
MXS_NOTICE("Failed to write to file '%s': %s", path, real_err);
modulecmd_set_error("Failed to write to file '%s': %s", path, real_err);
}
@ -124,8 +123,7 @@ static bool cdc_add_new_user(const MODULECMD_ARG *args)
}
else
{
char err[MXS_STRERROR_BUFLEN];
char *real_err = strerror_r(errno, err, sizeof(err));
const char *real_err = mxs_strerror(errno);
MXS_NOTICE("Failed to open file '%s': %s", path, real_err);
modulecmd_set_error("Failed to open file '%s': %s", path, real_err);
}

4
server/modules/filter/cache/rules.cc vendored
View File

@ -231,10 +231,8 @@ CACHE_RULES *cache_rules_load(const char *path, uint32_t debug)
}
else
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("Could not open rules file %s for reading: %s",
path, strerror_r(errno, errbuf, sizeof(errbuf)));
path, mxs_strerror(errno));
}
return rules;

12
server/modules/filter/cache/storage/storage_rocksdb/rocksdbstorage.cc vendored
View File

@ -70,8 +70,7 @@ bool deletePath(const string& path)
}
else
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("Could not stat: %s", strerror_r(errno, errbuf, sizeof(errbuf)));
MXS_ERROR("Could not stat: %s", mxs_strerror(errno));
}
}
else
@ -98,10 +97,9 @@ bool deletePath(const string& path)
case FTS_DNR:
case FTS_ERR:
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("Error while traversing %s: %s",
pCurrent->fts_accpath,
strerror_r(pCurrent->fts_errno, errbuf, sizeof(errbuf)));
mxs_strerror(pCurrent->fts_errno));
rv = false;
}
break;
@ -125,11 +123,10 @@ bool deletePath(const string& path)
case FTS_DEFAULT:
if (remove(pCurrent->fts_accpath) < 0)
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("Could not remove '%s', the cache directory may need to "
"be deleted manually: %s",
pCurrent->fts_accpath,
strerror_r(errno, errbuf, sizeof(errbuf)));
mxs_strerror(errno));
rv = false;
}
break;
@ -261,10 +258,9 @@ RocksDBStorage* RocksDBStorage::Create(const char* zName,
}
else if (errno != EEXIST)
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to create storage directory %s: %s",
storageDirectory.c_str(),
strerror_r(errno, errbuf, sizeof(errbuf)));
mxs_strerror(errno));
ok = false;
}

6
server/modules/filter/dbfwfilter/dbfwfilter.c
View File

@ -734,9 +734,8 @@ bool dbfw_reload_rules(const MODULECMD_ARG *argv)
}
else
{
char err[MXS_STRERROR_BUFLEN];
modulecmd_set_error("Failed to read rules at '%s': %d, %s", filename,
errno, strerror_r(errno, err, sizeof(err)));
errno, mxs_strerror(errno));
rval = false;
}
@ -1483,9 +1482,8 @@ static bool process_rule_file(const char* filename, RULE** rules, HASHTABLE **us
}
else
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to open rule file '%s': %d, %s", filename, errno,
strerror_r(errno, errbuf, sizeof(errbuf)));
mxs_strerror(errno));
}

4
server/modules/filter/masking/maskingrules.cc
View File

@ -783,10 +783,8 @@ auto_ptr<MaskingRules> MaskingRules::load(const char* zPath)
}
else
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("Could not open rules file %s for reading: %s",
zPath, strerror_r(errno, errbuf, sizeof(errbuf)));
zPath, mxs_strerror(errno));
}
return sRules;

6
server/modules/filter/qlafilter/qlafilter.c
View File

@ -327,11 +327,10 @@ createInstance(const char *name, char **options, MXS_CONFIG_PARAMETER *params)
if (my_instance->unified_fp == NULL)
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("Opening output file for qla "
"filter failed due to %d, %s",
errno,
strerror_r(errno, errbuf, sizeof(errbuf)));
mxs_strerror(errno));
error = true;
}
MXS_FREE(filename);
@ -427,11 +426,10 @@ newSession(MXS_FILTER *instance, MXS_SESSION *session)
if (my_session->fp == NULL)
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("Opening output file for qla "
"filter failed due to %d, %s",
errno,
strerror_r(errno, errbuf, sizeof(errbuf)));
mxs_strerror(errno));
MXS_FREE(my_session->filename);
MXS_FREE(my_session);
my_session = NULL;

8
server/modules/protocol/MySQL/MySQLBackend/mysql_backend.c
View File

@ -1119,16 +1119,15 @@ static int gw_error_backend_event(DCB *dcb)
if (getsockopt(dcb->fd, SOL_SOCKET, SO_ERROR, &error, (socklen_t *) & len) == 0 && error != 0)
{
char errstring[MXS_STRERROR_BUFLEN];
if (dcb->state != DCB_STATE_POLLING)
{
MXS_ERROR("DCB in state %s got error '%s'.", STRDCBSTATE(dcb->state),
strerror_r(error, errstring, sizeof(errstring)));
mxs_strerror(errno));
}
else
{
MXS_ERROR("Error '%s' in session that is not ready for routing.",
strerror_r(error, errstring, sizeof(errstring)));
mxs_strerror(errno));
}
}
}
@ -1168,10 +1167,9 @@ static int gw_backend_hangup(DCB *dcb)
{
if (error != 0 && session->state != SESSION_STATE_STOPPING)
{
char errstring[MXS_STRERROR_BUFLEN];
MXS_ERROR("Hangup in session that is not ready for routing, "
"Error reported is '%s'.",
strerror_r(error, errstring, sizeof(errstring)));
mxs_strerror(errno));
}
}
}

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

@ -150,10 +150,8 @@ static bool authenticate_socket(MAXSCALED *protocol, DCB *dcb)
}
else
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("Could not get socket family of client connection: %s",
strerror_r(errno, errbuf, sizeof(errbuf)));
mxs_strerror(errno));
}
return authenticated;

7
server/modules/routing/avrorouter/avro.c
View File

@ -1129,7 +1129,6 @@ static bool ensure_dir_ok(const char* path, int mode)
if (path)
{
char err[MXS_STRERROR_BUFLEN];
char resolved[PATH_MAX + 1];
const char *rp = realpath(path, resolved);
@ -1150,19 +1149,19 @@ static bool ensure_dir_ok(const char* path, int mode)
else
{
MXS_ERROR("Failed to access directory '%s': %d, %s", rp,
errno, strerror_r(errno, err, sizeof(err)));
errno, mxs_strerror(errno));
}
}
else
{
MXS_ERROR("Failed to create directory '%s': %d, %s", rp,
errno, strerror_r(errno, err, sizeof(err)));
errno, mxs_strerror(errno));
}
}
else
{
MXS_ERROR("Failed to resolve real path name for '%s': %d, %s", path,
errno, strerror_r(errno, err, sizeof(err)));
errno, mxs_strerror(errno));
}
}

3
server/modules/routing/avrorouter/avro_client.c
View File

@ -868,9 +868,8 @@ GWBUF* read_avro_json_schema(const char *avrofile, const char* dir)
}
else
{
char err[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to open file '%s': %d, %s", buffer, errno,
strerror_r(errno, err, sizeof(err)));
mxs_strerror(errno));
}
}
return rval;

14
server/modules/routing/avrorouter/avro_file.c
View File

@ -70,9 +70,8 @@ bool avro_open_binlog(const char *binlogdir, const char *file, int *dest)
{
if (errno != ENOENT)
{
char err[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to open binlog file %s: %d, %s", path, errno,
strerror_r(errno, err, sizeof(err)));
mxs_strerror(errno));
}
return false;
}
@ -166,7 +165,6 @@ bool avro_save_conversion_state(AVRO_INSTANCE *router)
{
FILE *config_file;
char filename[PATH_MAX + 1];
char err_msg[MXS_STRERROR_BUFLEN];
snprintf(filename, sizeof(filename), "%s/"AVRO_PROGRESS_FILE".tmp", router->avrodir);
@ -176,7 +174,7 @@ bool avro_save_conversion_state(AVRO_INSTANCE *router)
if (config_file == NULL)
{
MXS_ERROR("Failed to open file '%s': %d, %s", filename,
errno, strerror_r(errno, err_msg, sizeof(err_msg)));
errno, mxs_strerror(errno));
return false;
}
@ -195,7 +193,7 @@ bool avro_save_conversion_state(AVRO_INSTANCE *router)
if (rc == -1)
{
MXS_ERROR("Failed to rename file '%s' to '%s': %d, %s", filename, newname,
errno, strerror_r(errno, err_msg, sizeof(err_msg)));
errno, mxs_strerror(errno));
return false;
}
@ -425,11 +423,10 @@ static GWBUF* read_event_data(AVRO_INSTANCE *router, REP_HEADER* hdr, uint64_t p
{
if (n == -1)
{
char err_msg[MXS_STRERROR_BUFLEN];
MXS_ERROR("Error reading the event at %lu in %s. "
"%s, expected %d bytes.",
pos, router->binlog_name,
strerror_r(errno, err_msg, sizeof(err_msg)),
mxs_strerror(errno),
hdr->event_size - BINLOG_EVENT_HDR_LEN);
}
else
@ -519,10 +516,9 @@ avro_binlog_end_t avro_read_all_events(AVRO_INSTANCE *router)
break;
case -1:
{
char err_msg[BLRM_STRERROR_R_MSG_SIZE + 1] = "";
MXS_ERROR("Failed to read binlog file %s at position %llu (%s).",
router->binlog_name, pos,
strerror_r(errno, err_msg, sizeof(err_msg)));
mxs_strerror(errno));
if (errno == EBADF)
MXS_ERROR("Bad file descriptor in read binlog for file %s"

9
server/modules/routing/binlogrouter/blr.c
View File

@ -653,12 +653,11 @@ createInstance(SERVICE *service, char **options)
mkdir_rval = mkdir(inst->binlogdir, 0700);
if (mkdir_rval == -1)
{
char err_msg[MXS_STRERROR_BUFLEN];
MXS_ERROR("Service %s, Failed to create binlog directory '%s': [%d] %s",
service->name,
inst->binlogdir,
errno,
strerror_r(errno, err_msg, sizeof(err_msg)));
mxs_strerror(errno));
free_instance(inst);
return NULL;
@ -1788,8 +1787,7 @@ errorReply(MXS_ROUTER *instance,
getsockopt(router->master->fd, SOL_SOCKET, SO_ERROR, &error, &len) == 0 &&
error != 0)
{
char errbuf[MXS_STRERROR_BUFLEN];
sprintf(msg, "%s ", strerror_r(error, errbuf, sizeof(errbuf)));
sprintf(msg, "%s ", mxs_strerror(error));
}
else
{
@ -2622,10 +2620,9 @@ int blr_parse_key_file(ROUTER_INSTANCE *router)
if (!file)
{
char errbuf[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to open KEY file '%s': %s",
router->encryption.key_management_filename,
strerror_r(errno, errbuf, sizeof(errbuf)));
mxs_strerror(errno));
return -1;
}

49
server/modules/routing/binlogrouter/blr_file.c
View File

@ -307,10 +307,9 @@ blr_file_init(ROUTER_INSTANCE *router)
root_len = strlen(router->fileroot);
if ((dirp = opendir(path)) == NULL)
{
char err_msg[BLRM_STRERROR_R_MSG_SIZE];
MXS_ERROR("%s: Unable to read the binlog directory %s, %s.",
router->service->name, router->binlogdir,
strerror_r(errno, err_msg, sizeof(err_msg)));
mxs_strerror(errno));
return 0;
}
while ((dp = readdir(dirp)) != NULL)
@ -433,20 +432,20 @@ blr_file_create(ROUTER_INSTANCE *router, char *file)
else
{
MXS_ERROR("%s: Failed to write magic string to created binlog file %s, %s.",
router->service->name, path, strerror_r(errno, err_msg, sizeof(err_msg)));
router->service->name, path, mxs_strerror(errno));
close(fd);
if (!unlink(path))
{
MXS_ERROR("%s: Failed to delete file %s, %s.",
router->service->name, path, strerror_r(errno, err_msg, sizeof(err_msg)));
router->service->name, path, mxs_strerror(errno));
}
}
}
else
{
MXS_ERROR("%s: Failed to create binlog file %s, %s.",
router->service->name, path, strerror_r(errno, err_msg, sizeof(err_msg)));
router->service->name, path, mxs_strerror(errno));
}
return created;
@ -577,19 +576,18 @@ blr_write_binlog_record(ROUTER_INSTANCE *router, REP_HEADER *hdr, uint32_t size,
/* Check write operation result*/
if (n != size)
{
char err_msg[MXS_STRERROR_BUFLEN];
MXS_ERROR("%s: Failed to write binlog record at %lu of %s, %s. "
"Truncating to previous record.",
router->service->name, router->binlog_position,
router->binlog_name,
strerror_r(errno, err_msg, sizeof(err_msg)));
mxs_strerror(errno));
/* Remove any partial event that was written */
if (ftruncate(router->binlog_fd, router->binlog_position))
{
MXS_ERROR("%s: Failed to truncate binlog record at %lu of %s, %s. ",
router->service->name, router->binlog_position,
router->binlog_name,
strerror_r(errno, err_msg, sizeof(err_msg)));
mxs_strerror(errno));
}
return 0;
}
@ -836,9 +834,8 @@ blr_read_binlog(ROUTER_INSTANCE *router,
break;
case -1:
{
char err_msg[MXS_STRERROR_BUFLEN];
snprintf(errmsg, BINLOG_ERROR_MSG_LEN, "Failed to read binlog file '%s'; (%s), event at %lu",
file->binlogname, strerror_r(errno, err_msg, sizeof(err_msg)), pos);
file->binlogname, mxs_strerror(errno), pos);
if (errno == EBADF)
{
@ -899,10 +896,9 @@ blr_read_binlog(ROUTER_INSTANCE *router,
break;
case -1:
{
char err_msg[MXS_STRERROR_BUFLEN];
snprintf(errmsg, BINLOG_ERROR_MSG_LEN,
"Failed to reread header in binlog file '%s'; (%s), event at %lu",
file->binlogname, strerror_r(errno, err_msg, sizeof(err_msg)), pos);
file->binlogname, mxs_strerror(errno), pos);
if (errno == EBADF)
{
@ -983,13 +979,12 @@ blr_read_binlog(ROUTER_INSTANCE *router,
if (n == -1)
{
char err_msg[MXS_STRERROR_BUFLEN];
snprintf(errmsg, BINLOG_ERROR_MSG_LEN,
"Error reading the binlog event at %lu in binlog file '%s';"
"(%s), expected %d bytes.",
pos,
file->binlogname,
strerror_r(errno, err_msg, sizeof(err_msg)),
mxs_strerror(errno),
hdr->event_size - BINLOG_EVENT_HDR_LEN);
}
else
@ -1199,9 +1194,8 @@ blr_cache_response(ROUTER_INSTANCE *router, char *response, GWBUF *buf)
}
if (write(fd, GWBUF_DATA(buf), GWBUF_LENGTH(buf)) == -1)
{
char err[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to write cached response: %d, %s",
errno, strerror_r(errno, err, sizeof(err)));
errno, mxs_strerror(errno));
}
close(fd);
@ -1257,9 +1251,8 @@ blr_cache_read_response(ROUTER_INSTANCE *router, char *response)
}
if (read(fd, GWBUF_DATA(buf), statb.st_size) == -1)
{
char err[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to read cached response: %d, %s",
errno, strerror_r(errno, err, sizeof(err)));
errno, mxs_strerror(errno));
}
close(fd);
return buf;
@ -1438,10 +1431,9 @@ blr_read_events_all_events(ROUTER_INSTANCE *router,
break;
case -1:
{
char err[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to read binlog file %s at position %llu"
" (%s).", router->binlog_name, pos,
strerror_r(errno, err, sizeof(err)));
mxs_strerror(errno));
if (errno == EBADF)
{
@ -1657,11 +1649,10 @@ blr_read_events_all_events(ROUTER_INSTANCE *router,
{
if (n == -1)
{
char err[MXS_STRERROR_BUFLEN];
MXS_ERROR("Error reading the event at %llu in %s. "
"%s, expected %d bytes.",
pos, router->binlog_name,
strerror_r(errno, err, sizeof(err)),
mxs_strerror(errno),
hdr.event_size - BINLOG_EVENT_HDR_LEN);
}
else
@ -2443,7 +2434,6 @@ blr_file_write_master_config(ROUTER_INSTANCE *router, char *error)
char filename[len + sizeof('/') + sizeof(MASTER_INI)]; // sizeof includes NULL
char tmp_file[len + sizeof('/') + sizeof(MASTER_INI) + sizeof('.') + sizeof(TMP)];
char err_msg[MXS_STRERROR_BUFLEN];
char *ssl_ca;
char *ssl_cert;
char *ssl_key;
@ -2457,7 +2447,7 @@ blr_file_write_master_config(ROUTER_INSTANCE *router, char *error)
if (config_file == NULL)
{
snprintf(error, BINLOG_ERROR_MSG_LEN, "%s, errno %u",
strerror_r(errno, err_msg, sizeof(err_msg)), errno);
mxs_strerror(errno), errno);
return 2;
}
@ -2465,7 +2455,7 @@ blr_file_write_master_config(ROUTER_INSTANCE *router, char *error)
{
fclose(config_file);
snprintf(error, BINLOG_ERROR_MSG_LEN, "%s, errno %u",
strerror_r(errno, err_msg, sizeof(err_msg)), errno);
mxs_strerror(errno), errno);
return 2;
}
@ -2517,14 +2507,14 @@ blr_file_write_master_config(ROUTER_INSTANCE *router, char *error)
if (rc == -1)
{
snprintf(error, BINLOG_ERROR_MSG_LEN, "%s, errno %u",
strerror_r(errno, err_msg, sizeof(err_msg)), errno);
mxs_strerror(errno), errno);
return 3;
}
if (chmod(filename, S_IRUSR | S_IWUSR) < 0)
{
snprintf(error, BINLOG_ERROR_MSG_LEN, "%s, errno %u",
strerror_r(errno, err_msg, sizeof(err_msg)), errno);
mxs_strerror(errno), errno);
return 3;
}
@ -2724,12 +2714,11 @@ blr_write_special_event(ROUTER_INSTANCE *router, uint32_t file_offset, uint32_t
/* Write the event */
if ((n = pwrite(router->binlog_fd, new_event, event_size, router->last_written)) != event_size)
{
char err_msg[MXS_STRERROR_BUFLEN];
MXS_ERROR("%s: Failed to write %s special binlog record at %lu of %s, %s. "
"Truncating to previous record.",
router->service->name, new_event_desc, (unsigned long)file_offset,
router->binlog_name,
strerror_r(errno, err_msg, sizeof(err_msg)));
mxs_strerror(errno));
/* Remove any partial event that was written */
if (ftruncate(router->binlog_fd, router->binlog_position))
@ -2737,7 +2726,7 @@ blr_write_special_event(ROUTER_INSTANCE *router, uint32_t file_offset, uint32_t
MXS_ERROR("%s: Failed to truncate %s special binlog record at %lu of %s, %s. ",
router->service->name, new_event_desc, (unsigned long)file_offset,
router->binlog_name,
strerror_r(errno, err_msg, sizeof(err_msg)));
mxs_strerror(errno));
}
MXS_FREE(new_event);
return 0;

11
server/modules/routing/binlogrouter/blr_master.c
View File

@ -2015,11 +2015,10 @@ GWBUF
break;
case -1:
{
char err_msg[MXS_STRERROR_BUFLEN];
MXS_ERROR("Reading saved events: failed to read binlog "
"file %s at position %llu"
" (%s).", router->binlog_name,
pos, strerror_r(errno, err_msg, sizeof(err_msg)));
pos, mxs_strerror(errno));
if (errno == EBADF)
{
@ -2075,11 +2074,10 @@ GWBUF
{
if (n == -1)
{
char err_msg[MXS_STRERROR_BUFLEN];
MXS_ERROR("Reading saved events: the event at %llu in %s. "
"%s, expected %d bytes.",
pos, router->binlog_name,
strerror_r(errno, err_msg, sizeof(err_msg)), hdr->event_size - 19);
mxs_strerror(errno), hdr->event_size - 19);
}
else
{
@ -2327,12 +2325,11 @@ blr_write_data_into_binlog(ROUTER_INSTANCE *router, uint32_t data_len, uint8_t *
if ((n = pwrite(router->binlog_fd, buf, data_len,
router->last_written)) != data_len)
{
char err_msg[MXS_STRERROR_BUFLEN];
MXS_ERROR("%s: Failed to write binlog record at %lu of %s, %s. "
"Truncating to previous record.",
router->service->name, router->binlog_position,
router->binlog_name,
strerror_r(errno, err_msg, sizeof(err_msg)));
mxs_strerror(errno));
/* Remove any partial event that was written */
if (ftruncate(router->binlog_fd, router->binlog_position))
@ -2340,7 +2337,7 @@ blr_write_data_into_binlog(ROUTER_INSTANCE *router, uint32_t data_len, uint8_t *
MXS_ERROR("%s: Failed to truncate binlog record at %lu of %s, %s. ",
router->service->name, router->last_written,
router->binlog_name,
strerror_r(errno, err_msg, sizeof(err_msg)));
mxs_strerror(errno));
}
return 0;
}

6
server/modules/routing/binlogrouter/blr_slave.c
View File

@ -1008,10 +1008,9 @@ blr_slave_query(ROUTER_INSTANCE *router, ROUTER_SLAVE *slave, GWBUF *queue)
if (removed_cfg == -1)
{
char err_msg[MXS_STRERROR_BUFLEN];
snprintf(error_string, BINLOG_ERROR_MSG_LEN,
"Error removing %s, %s, errno %u", path,
strerror_r(errno, err_msg, sizeof(err_msg)), errno);
mxs_strerror(errno), errno);
MXS_ERROR("%s: %s", router->service->name, error_string);
}
@ -3677,9 +3676,8 @@ blr_start_slave(ROUTER_INSTANCE* router, ROUTER_SLAVE* slave)
/* Truncate previous binlog file to last_safe pos */
if (truncate(file, router->last_safe_pos) == -1)
{
char err[MXS_STRERROR_BUFLEN];
MXS_ERROR("Failed to truncate file: %d, %s",
errno, strerror_r(errno, err, sizeof(err)));
errno, mxs_strerror(errno));
}
/* Log it */