pdxx
/
libserverframe
mirror of https://github.com/happyfish100/libserverframe.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
libserverframe/src/sf_global.c

1144 lines
38 KiB
C
Raw Blame History

/*
* Copyright (c) 2020 YuQing <384681@qq.com>
*
* This program is free software: you can use, redistribute, and/or modify
* it under the terms of the GNU Affero General Public License, version 3
* or later ("AGPL"), as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <dlfcn.h>
#include <errno.h>
#include <grp.h>
#include <pwd.h>
#include "fastcommon/common_define.h"
#include "fastcommon/shared_func.h"
#include "fastcommon/process_ctrl.h"
#include "fastcommon/local_ip_func.h"
#include "fastcommon/logger.h"
#include "sf_nio.h"
#include "sf_service.h"
#include "sf_global.h"
SFGlobalVariables g_sf_global_vars = {
{{'/', 't', 'm', 'p', '\0'}, false},
true, true, false, { SF_DEFAULT_CONNECT_TIMEOUT,
SF_DEFAULT_NETWORK_TIMEOUT, DEFAULT_MAX_CONNECTONS,
SF_DEF_MAX_PACKAGE_SIZE, SF_DEF_MIN_BUFF_SIZE,
SF_DEF_MAX_BUFF_SIZE}, 0, SF_DEF_THREAD_STACK_SIZE, 0,
{false, 0, 0, {'\0'}, {'\0'}},
{SF_DEF_SYNC_LOG_BUFF_INTERVAL, false},
{0, 0}, NULL, {NULL, 0}
};
SFContext g_sf_context = {{'\0'}, NULL, 0, false, false, false,
sf_address_family_auto, {{AF_UNSPEC, {{true, fc_comm_type_sock},
{false, fc_comm_type_rdma}}},
{AF_UNSPEC, {{true, fc_comm_type_sock}, {false, fc_comm_type_rdma}}}},
{DEFAULT_MAX_CONNECTONS, SF_DEF_MAX_PACKAGE_SIZE, SF_DEF_MIN_BUFF_SIZE,
SF_DEF_MAX_BUFF_SIZE}, 1, DEFAULT_WORK_THREADS, 0, true, true,
{false, 0, 0}, {sf_task_finish_clean_up}
};
static int load_network_parameters(IniFullContext *ini_ctx,
const char *max_pkg_size_item_nm, const int max_pkg_size_min_value,
const int fixed_buff_size, const int task_buffer_extra_size,
SFNetBufferConfig *net_buffer_cfg)
{
int padding_buff_size;
char *pMinBuffSize;
char *pMaxBuffSize;
net_buffer_cfg->connect_timeout = iniGetIntValueEx(ini_ctx->
section_name, "connect_timeout", ini_ctx->context,
SF_DEFAULT_CONNECT_TIMEOUT, true);
if (net_buffer_cfg->connect_timeout <= 0) {
net_buffer_cfg->connect_timeout = SF_DEFAULT_CONNECT_TIMEOUT;
}
net_buffer_cfg->network_timeout = iniGetIntValueEx(ini_ctx->
section_name, "network_timeout", ini_ctx->context,
SF_DEFAULT_NETWORK_TIMEOUT, true);
if (net_buffer_cfg->network_timeout <= 0) {
net_buffer_cfg->network_timeout = SF_DEFAULT_NETWORK_TIMEOUT;
}
net_buffer_cfg->max_connections = iniGetIntValueEx(ini_ctx->section_name,
"max_connections", ini_ctx->context, DEFAULT_MAX_CONNECTONS, true);
if (net_buffer_cfg->max_connections <= 0) {
net_buffer_cfg->max_connections = DEFAULT_MAX_CONNECTONS;
}
if (fixed_buff_size > 0) {
padding_buff_size = FC_MAX(fixed_buff_size, max_pkg_size_min_value) +
task_buffer_extra_size;
net_buffer_cfg->min_buff_size = padding_buff_size;
net_buffer_cfg->max_buff_size = padding_buff_size;
net_buffer_cfg->max_pkg_size = padding_buff_size;
return 0;
}
net_buffer_cfg->max_pkg_size = iniGetByteCorrectValueEx(ini_ctx,
max_pkg_size_item_nm, SF_DEF_MAX_PACKAGE_SIZE, 1, 8192,
SF_MAX_NETWORK_BUFF_SIZE, true);
if (net_buffer_cfg->max_pkg_size < max_pkg_size_min_value) {
net_buffer_cfg->max_pkg_size = max_pkg_size_min_value;
}
if (task_buffer_extra_size > 0) {
net_buffer_cfg->max_pkg_size += task_buffer_extra_size;
}
pMinBuffSize = iniGetStrValueEx(ini_ctx->section_name,
"min_buff_size", ini_ctx->context, true);
pMaxBuffSize = iniGetStrValueEx(ini_ctx->section_name,
"max_buff_size", ini_ctx->context, true);
if (pMinBuffSize == NULL || pMaxBuffSize == NULL) {
net_buffer_cfg->min_buff_size = net_buffer_cfg->max_pkg_size;
net_buffer_cfg->max_buff_size = net_buffer_cfg->max_pkg_size;
} else {
net_buffer_cfg->min_buff_size = iniGetByteCorrectValueEx(ini_ctx,
"min_buff_size", SF_DEF_MIN_BUFF_SIZE, 1, 4096,
SF_MAX_NETWORK_BUFF_SIZE, true);
net_buffer_cfg->max_buff_size = iniGetByteCorrectValueEx(ini_ctx,
"max_buff_size", SF_DEF_MAX_BUFF_SIZE, 1, 8192,
SF_MAX_NETWORK_BUFF_SIZE, true);
if (task_buffer_extra_size > 0) {
net_buffer_cfg->min_buff_size += task_buffer_extra_size;
net_buffer_cfg->max_buff_size += task_buffer_extra_size;
}
if (net_buffer_cfg->max_buff_size < net_buffer_cfg->max_pkg_size) {
net_buffer_cfg->max_buff_size = net_buffer_cfg->max_pkg_size;
} else if (net_buffer_cfg->max_pkg_size <
net_buffer_cfg->max_buff_size)
{
net_buffer_cfg->max_pkg_size = net_buffer_cfg->max_buff_size;
}
if (net_buffer_cfg->max_buff_size < net_buffer_cfg->min_buff_size) {
logWarning("file: "__FILE__", line: %d, "
"max_buff_size: %d < min_buff_size: %d, "
"set max_buff_size to min_buff_size", __LINE__,
net_buffer_cfg->max_buff_size,
net_buffer_cfg->min_buff_size);
net_buffer_cfg->max_buff_size = net_buffer_cfg->min_buff_size;
}
}
return 0;
}
void sf_set_log_rotate_size(LogContext *log_ctx, const int64_t rotate_on_size)
{
if (rotate_on_size > 0) {
log_ctx->rotate_size = rotate_on_size;
log_set_rotate_time_format(log_ctx, "%Y%m%d_%H%M%S");
} else {
log_ctx->rotate_size = 0;
log_set_rotate_time_format(log_ctx, "%Y%m%d");
}
}
int sf_load_log_config(IniFullContext *ini_ctx, LogContext *log_ctx,
SFLogConfig *log_cfg)
{
int result;
log_cfg->sync_log_buff_interval = iniGetIntValueEx(
ini_ctx->section_name, "sync_log_buff_interval",
ini_ctx->context, SF_DEF_SYNC_LOG_BUFF_INTERVAL, true);
if (log_cfg->sync_log_buff_interval <= 0) {
log_cfg->sync_log_buff_interval = SF_DEF_SYNC_LOG_BUFF_INTERVAL;
}
log_cfg->rotate_everyday = iniGetBoolValueEx(ini_ctx->section_name,
"log_file_rotate_everyday", ini_ctx->context, true, true);
log_cfg->keep_days = iniGetIntValueEx(ini_ctx->section_name,
"log_file_keep_days", ini_ctx->context, 15, true);
log_cfg->compress_old = iniGetBoolValueEx(ini_ctx->section_name,
"log_file_compress_old", ini_ctx->context, false, true);
log_cfg->compress_days_before = iniGetIntValueEx(ini_ctx->section_name,
"log_file_compress_days_before", ini_ctx->context, 1, true);
if (log_cfg->compress_old) {
log_set_compress_log_flags_ex(log_ctx, LOG_COMPRESS_FLAGS_ENABLED |
LOG_COMPRESS_FLAGS_NEW_THREAD);
log_set_compress_log_days_before_ex(log_ctx,
log_cfg->compress_days_before);
}
if ((result=get_time_item_from_conf_ex(ini_ctx, "log_file_rotate_time",
&log_cfg->rotate_time, 0, 0, true)) != 0)
{
return result;
}
if ((result=get_time_item_from_conf_ex(ini_ctx, "log_file_delete_old_time",
&log_cfg->delete_old_time, 1, 30, true)) != 0)
{
return result;
}
log_cfg->rotate_on_size = iniGetByteCorrectValueEx(ini_ctx,
"log_file_rotate_on_size", 0, 1, 0,
64 * 1024 * 1024 * 1024LL, true);
sf_set_log_rotate_size(log_ctx, log_cfg->rotate_on_size);
return 0;
}
int sf_load_slow_log_config_ex(IniFullContext *ini_ctx, LogContext *log_ctx,
SFSlowLogConfig *slow_log_cfg)
{
int result;
char *filename_prefix;
if ((result=sf_load_log_config(ini_ctx, log_ctx,
&slow_log_cfg->log_cfg)) != 0)
{
return result;
}
slow_log_cfg->enabled = iniGetBoolValue(ini_ctx->section_name,
"enabled", ini_ctx->context, false);
slow_log_cfg->log_slower_than_ms = iniGetIntValue(ini_ctx->section_name,
"log_slower_than_ms", ini_ctx->context, 100);
filename_prefix = iniGetStrValue(ini_ctx->section_name,
"filename_prefix", ini_ctx->context);
if (filename_prefix == NULL || *filename_prefix == '\0') {
strcpy(slow_log_cfg->filename_prefix, "slow");
} else {
fc_safe_strcpy(slow_log_cfg->filename_prefix, filename_prefix);
}
return 0;
}
int sf_get_base_path_from_conf_file(const char *config_filename)
{
int result;
if (SF_G_BASE_PATH_INITED) {
return 0;
}
result = get_base_path_from_conf_file_ex(config_filename,
SF_G_BASE_PATH_STR, sizeof(SF_G_BASE_PATH_STR), LOG_NOTHING);
if (result != 0) {
if (result == ENOENT) {
if ((result=fc_check_mkdir_ex(SF_G_BASE_PATH_STR,
0775, &SF_G_BASE_PATH_CREATED)) != 0)
{
return result;
}
} else {
return result;
}
}
SF_G_BASE_PATH_LEN = strlen(SF_G_BASE_PATH_STR);
SF_G_BASE_PATH_INITED = true;
return 0;
}
int sf_load_global_base_path(IniFullContext *ini_ctx)
{
int result;
char *pBasePath;
if (!SF_G_BASE_PATH_INITED) {
pBasePath = iniGetStrValue(NULL, "base_path", ini_ctx->context);
if (pBasePath == NULL || *pBasePath == '\0') {
logError("file: "__FILE__", line: %d, "
"conf file \"%s\" must have item "
"\"base_path\"!", __LINE__, ini_ctx->filename);
return ENOENT;
}
sf_set_global_base_path(pBasePath);
}
chopPath(SF_G_BASE_PATH_STR);
SF_G_BASE_PATH_LEN = strlen(SF_G_BASE_PATH_STR);
if (!fileExists(SF_G_BASE_PATH_STR)) {
if ((result=fc_check_mkdir_ex(SF_G_BASE_PATH_STR, 0775,
&SF_G_BASE_PATH_CREATED)) != 0)
{
return result;
}
}
if (!isDir(SF_G_BASE_PATH_STR)) {
logError("file: "__FILE__", line: %d, "
"\"%s\" is not a directory!",
__LINE__, SF_G_BASE_PATH_STR);
return ENOTDIR;
}
return 0;
}
int sf_load_global_config_ex(const char *log_filename_prefix,
IniFullContext *ini_ctx, const bool load_network_params,
const char *max_pkg_size_item_nm, const int fixed_buff_size,
const int task_buffer_extra_size, const bool need_set_run_by)
{
const int max_pkg_size_min_value = 0;
int result;
const char *old_section_name;
char *pRunByGroup;
char *pRunByUser;
if ((result=sf_load_global_base_path(ini_ctx)) != 0) {
return result;
}
g_sf_global_vars.task_buffer_extra_size = task_buffer_extra_size;
g_sf_global_vars.tcp_quick_ack = iniGetBoolValue(NULL,
"tcp_quick_ack", ini_ctx->context, true);
tcp_set_quick_ack(g_sf_global_vars.tcp_quick_ack);
if (load_network_params) {
if ((result=load_network_parameters(ini_ctx, max_pkg_size_item_nm,
max_pkg_size_min_value, fixed_buff_size,
task_buffer_extra_size, &g_sf_global_vars.
net_buffer_cfg)) != 0)
{
return result;
}
if ((result=set_rlimit(RLIMIT_NOFILE, g_sf_global_vars.
net_buffer_cfg.max_connections)) != 0)
{
return result;
}
}
pRunByGroup = iniGetStrValue(NULL, "run_by_group", ini_ctx->context);
pRunByUser = iniGetStrValue(NULL, "run_by_user", ini_ctx->context);
if (pRunByGroup == NULL) {
*g_sf_global_vars.run_by.group = '\0';
}
else {
fc_safe_strcpy(g_sf_global_vars.run_by.group, pRunByGroup);
}
if (*(g_sf_global_vars.run_by.group) == '\0') {
g_sf_global_vars.run_by.gid = getegid();
}
else {
struct group *pGroup;
pGroup = getgrnam(g_sf_global_vars.run_by.group);
if (pGroup == NULL) {
result = errno != 0 ? errno : ENOENT;
logError("file: "__FILE__", line: %d, "
"getgrnam fail, errno: %d, "
"error info: %s", __LINE__,
result, strerror(result));
return result;
}
g_sf_global_vars.run_by.gid = pGroup->gr_gid;
}
if (pRunByUser == NULL) {
*g_sf_global_vars.run_by.user = '\0';
}
else {
fc_safe_strcpy(g_sf_global_vars.run_by.user, pRunByUser);
}
if (*(g_sf_global_vars.run_by.user) == '\0') {
g_sf_global_vars.run_by.uid = geteuid();
}
else {
struct passwd *pUser;
pUser = getpwnam(g_sf_global_vars.run_by.user);
if (pUser == NULL) {
result = errno != 0 ? errno : ENOENT;
logError("file: "__FILE__", line: %d, "
"getpwnam fail, errno: %d, "
"error info: %s", __LINE__,
result, strerror(result));
return result;
}
g_sf_global_vars.run_by.uid = pUser->pw_uid;
}
g_sf_global_vars.run_by.inited = true;
if (SF_G_BASE_PATH_CREATED) {
SF_CHOWN_TO_RUNBY_RETURN_ON_ERROR(SF_G_BASE_PATH_STR);
}
if (need_set_run_by) {
if ((result=set_run_by(g_sf_global_vars.run_by.group,
g_sf_global_vars.run_by.user)) != 0)
{
return result;
}
}
g_sf_global_vars.thread_stack_size = iniGetByteCorrectValueEx(ini_ctx,
"thread_stack_size", SF_DEF_THREAD_STACK_SIZE, 1,
SF_MIN_THREAD_STACK_SIZE, SF_MAX_THREAD_STACK_SIZE, true);
old_section_name = ini_ctx->section_name;
ini_ctx->section_name = "error-log";
if ((result=sf_load_log_config(ini_ctx, &g_log_context,
&g_sf_global_vars.error_log)) != 0)
{
return result;
}
ini_ctx->section_name = old_section_name;
load_log_level(ini_ctx->context);
if (log_filename_prefix != NULL) {
if ((result=log_set_prefix(SF_G_BASE_PATH_STR,
log_filename_prefix)) != 0)
{
return result;
}
}
return 0;
}
int sf_load_config_ex(const char *log_filename_prefix,
SFContextIniConfig *config, const int fixed_buff_size,
const int task_buffer_extra_size, const bool need_set_run_by)
{
int result;
if ((result=sf_load_global_config_ex(log_filename_prefix, &config->ini_ctx,
true, config->max_pkg_size_item_name, fixed_buff_size,
task_buffer_extra_size, need_set_run_by)) != 0)
{
return result;
}
return sf_load_context_from_config_ex(&g_sf_context, config,
fixed_buff_size, task_buffer_extra_size);
}
#define API_PREFIX_NAME "fast_rdma_"
#define LOAD_API_EX(handler, prefix, fname) \
do { \
handler->fname = dlsym(dlhandle, API_PREFIX_NAME#prefix#fname); \
if (handler->fname == NULL) { \
logError("file: "__FILE__", line: %d, " \
"dlsym api %s fail, error info: %s", \
__LINE__, API_PREFIX_NAME#prefix#fname, dlerror()); \
return ENOENT; \
} \
} while (0)
#define LOAD_API(handler, fname) LOAD_API_EX(handler, server_, fname)
static int load_rdma_apis(SFContext *sf_context, SFNetworkHandler *handler)
{
const char *library = "libfastrdma.so";
void *dlhandle;
dlhandle = dlopen(library, RTLD_LAZY);
if (dlhandle == NULL) {
logError("file: "__FILE__", line: %d, "
"dlopen %s fail, error info: %s",
__LINE__, library, dlerror());
return EFAULT;
}
LOAD_API(handler, get_connection_size);
LOAD_API(handler, init_connection);
if (sf_context->is_client) {
LOAD_API_EX(handler, client_, alloc_pd);
} else {
LOAD_API(handler, alloc_pd);
}
LOAD_API_EX(handler, , create_server);
LOAD_API_EX(handler, , close_server);
LOAD_API(handler, accept_connection);
LOAD_API_EX(handler, , async_connect_server);
LOAD_API_EX(handler, , async_connect_check);
LOAD_API(handler, close_connection);
LOAD_API(handler, send_data);
LOAD_API(handler, recv_data);
LOAD_API(handler, post_recv);
return 0;
}
static int init_network_handler(SFContext *sf_context,
SFNetworkHandler *handler, SFAddressFamilyHandler *fh)
{
handler->fh = fh;
handler->inner.handler = handler;
handler->outer.handler = handler;
handler->inner.is_inner = true;
handler->outer.is_inner = false;
handler->explicit_post_recv = false;
if (handler->comm_type == fc_comm_type_sock) {
handler->inner.sock = -1;
handler->outer.sock = -1;
handler->create_server = sf_socket_create_server;
handler->close_server = sf_socket_close_server;
handler->accept_connection = sf_socket_accept_connection;
handler->async_connect_server = sf_socket_async_connect_server;
handler->async_connect_check = sf_socket_async_connect_check;
handler->close_connection = sf_socket_close_connection;
handler->send_data = sf_socket_send_data;
handler->recv_data = sf_socket_recv_data;
handler->post_recv = NULL;
return 0;
} else {
handler->inner.id = NULL;
handler->outer.id = NULL;
return load_rdma_apis(sf_context, handler);
}
}
static void set_bind_address(const char *bind_addr, char *ipv4_bind_addr,
char *ipv6_bind_addr, const int addr_size)
{
char new_bind_addr[2 * IP_ADDRESS_SIZE];
char *cols[2];
char *ip_addr;
int count;
int len;
int i;
if (bind_addr == NULL || *bind_addr == '\0') {
*ipv4_bind_addr = *ipv6_bind_addr = '\0';
return;
}
fc_safe_strcpy(new_bind_addr, bind_addr);
count = splitEx(new_bind_addr, ',', cols, 2);
for (i=0; i<count; i++) {
ip_addr = cols[i];
if (is_ipv6_addr(ip_addr)) {
len = strlen(ip_addr);
if (*ip_addr == '[' && *(ip_addr + (len - 1)) == ']') {
++ip_addr;
len -= 2;
}
if (len >= addr_size) {
len = addr_size - 1;
}
memcpy(ipv6_bind_addr, ip_addr, len);
*(ipv6_bind_addr + len) = '\0';
} else {
fc_strlcpy(ipv4_bind_addr, ip_addr, addr_size);
}
}
}
static int load_bind_address(SFContext *sf_context,
SFContextIniConfig *config)
{
char *inner_bind_addr;
char *outer_bind_addr;
char *bind_addr;
SFAddressFamilyHandler *ipv4_handler;
SFAddressFamilyHandler *ipv6_handler;
inner_bind_addr = iniGetStrValue(config->ini_ctx.section_name,
"inner_bind_addr", config->ini_ctx.context);
outer_bind_addr = iniGetStrValue(config->ini_ctx.section_name,
"outer_bind_addr", config->ini_ctx.context);
if (inner_bind_addr == NULL && outer_bind_addr == NULL) {
bind_addr = iniGetStrValue(config->ini_ctx.section_name,
"bind_addr", config->ini_ctx.context);
if (bind_addr != NULL) {
inner_bind_addr = outer_bind_addr = bind_addr;
}
}
ipv4_handler = sf_context->handlers + SF_IPV4_ADDRESS_FAMILY_INDEX;
ipv6_handler = sf_context->handlers + SF_IPV6_ADDRESS_FAMILY_INDEX;
set_bind_address(inner_bind_addr, ipv4_handler->inner_bind_addr,
ipv6_handler->inner_bind_addr,
sizeof(ipv4_handler->inner_bind_addr));
set_bind_address(outer_bind_addr, ipv4_handler->outer_bind_addr,
ipv6_handler->outer_bind_addr,
sizeof(ipv4_handler->outer_bind_addr));
return 0;
}
static int load_address_family(SFContext *sf_context,
SFContextIniConfig *config)
{
char *address_family_str;
SFAddressFamily address_family;
SFAddressFamilyHandler *ipv4_handler;
SFAddressFamilyHandler *ipv6_handler;
bool ipv4_bound;
bool ipv6_bound;
address_family_str = iniGetStrValue(config->ini_ctx.section_name,
"address_family", config->ini_ctx.context);
if (address_family_str == NULL) {
sf_context->address_family = sf_address_family_auto;
} else if (strcasecmp(address_family_str, "auto") == 0) {
sf_context->address_family = sf_address_family_auto;
} else if (strcasecmp(address_family_str, "IPv4") == 0) {
sf_context->address_family = sf_address_family_ipv4;
} else if (strcasecmp(address_family_str, "IPv6") == 0) {
sf_context->address_family = sf_address_family_ipv6;
} else if (strcasecmp(address_family_str, "both") == 0) {
sf_context->address_family = sf_address_family_both;
} else {
logError("file: "__FILE__", line: %d, "
"config file: %s, section: %s, address_family: %s "
"is invalid!", __LINE__, config->ini_ctx.filename,
config->ini_ctx.section_name, address_family_str);
return EINVAL;
}
ipv4_handler = sf_context->handlers + SF_IPV4_ADDRESS_FAMILY_INDEX;
ipv6_handler = sf_context->handlers + SF_IPV6_ADDRESS_FAMILY_INDEX;
if (sf_context->address_family == sf_address_family_auto) {
ipv4_bound = (*ipv4_handler->inner_bind_addr != '\0' ||
*ipv4_handler->outer_bind_addr != '\0');
ipv6_bound = (*ipv6_handler->inner_bind_addr != '\0' ||
*ipv6_handler->outer_bind_addr != '\0');
if (ipv4_bound) {
if (ipv6_bound) {
address_family = sf_address_family_both;
} else {
address_family = sf_address_family_ipv4;
}
} else {
if (ipv6_bound) {
address_family = sf_address_family_ipv6;
} else {
int ipv4_count;
int ipv6_count;
stat_local_host_ip(&ipv4_count, &ipv6_count);
if (ipv4_count > 0) {
address_family = sf_address_family_ipv4;
} else {
address_family = sf_address_family_ipv6;
}
}
}
} else {
address_family = sf_context->address_family;
}
switch (address_family) {
case sf_address_family_ipv4:
ipv4_handler->af = AF_INET;
ipv6_handler->af = AF_UNSPEC;
break;
case sf_address_family_ipv6:
ipv4_handler->af = AF_UNSPEC;
ipv6_handler->af = AF_INET6;
break;
case sf_address_family_both:
ipv4_handler->af = AF_INET;
ipv6_handler->af = AF_INET6;
break;
default:
break;
}
return 0;
}
int sf_load_context_from_config_ex(SFContext *sf_context,
SFContextIniConfig *config, const int fixed_buff_size,
const int task_buffer_extra_size)
{
SFAddressFamilyHandler *fh;
SFNetworkHandler *sock_handler;
SFNetworkHandler *rdma_handler;
SFNetworkHandler *handler;
SFNetworkHandler *end;
char *inner_port_str;
char *outer_port_str;
int inner_port;
int outer_port;
int port;
#if IOEVENT_USE_URING
bool global_use_send_zc;
bool use_send_zc;
#endif
int i;
int result;
inner_port_str = iniGetStrValue(config->ini_ctx.section_name,
"inner_port", config->ini_ctx.context);
outer_port_str = iniGetStrValue(config->ini_ctx.section_name,
"outer_port", config->ini_ctx.context);
if (inner_port_str == NULL && outer_port_str == NULL) {
port = iniGetIntValue(config->ini_ctx.section_name,
"port", config->ini_ctx.context, 0);
if (port > 0) {
inner_port = outer_port = port;
} else {
inner_port = outer_port = 0;
}
} else {
if (inner_port_str != NULL) {
inner_port = strtol(inner_port_str, NULL, 10);
} else {
inner_port = 0;
}
if (outer_port_str != NULL) {
outer_port = strtol(outer_port_str, NULL, 10);
} else {
outer_port = 0;
}
}
if (inner_port <= 0) {
inner_port = config->default_inner_port;
}
if (outer_port <= 0) {
outer_port = config->default_outer_port;
}
#if IOEVENT_USE_URING
global_use_send_zc = iniGetBoolValue(NULL, "use_send_zc",
config->ini_ctx.context, true);
if (config->ini_ctx.section_name == NULL) {
use_send_zc = global_use_send_zc;
} else {
use_send_zc = iniGetBoolValue(config->ini_ctx.section_name,
"use_send_zc", config->ini_ctx.context, global_use_send_zc);
}
#endif
for (i=0; i<SF_ADDRESS_FAMILY_COUNT; i++) {
fh = sf_context->handlers + i;
fh->ctx = sf_context;
sock_handler = fh->handlers + SF_SOCKET_NETWORK_HANDLER_INDEX;
rdma_handler = fh->handlers + SF_RDMACM_NETWORK_HANDLER_INDEX;
sock_handler->comm_type = fc_comm_type_sock;
rdma_handler->comm_type = fc_comm_type_rdma;
if (config->comm_type == fc_comm_type_sock) {
sock_handler->enabled = true;
rdma_handler->enabled = false;
} else if (config->comm_type == fc_comm_type_rdma) {
sock_handler->enabled = false;
rdma_handler->enabled = true;
} else if (config->comm_type == fc_comm_type_both) {
sock_handler->enabled = true;
rdma_handler->enabled = true;
}
end = fh->handlers + SF_NETWORK_HANDLER_COUNT;
for (handler=fh->handlers; handler<end; handler++) {
if (!handler->enabled) {
continue;
}
if ((result=init_network_handler(sf_context, handler, fh)) != 0) {
return result;
}
}
sock_handler->inner.port = inner_port;
sock_handler->outer.port = outer_port;
if (sock_handler->inner.port == sock_handler->outer.port) {
sock_handler->inner.enabled = true;
sock_handler->outer.enabled = false;
} else {
sock_handler->inner.enabled = true;
sock_handler->outer.enabled = true;
}
rdma_handler->inner.port = sock_handler->inner.port;
rdma_handler->inner.enabled = sock_handler->inner.enabled;
rdma_handler->outer.port = sock_handler->outer.port;
rdma_handler->outer.enabled = sock_handler->outer.enabled;
}
#if IOEVENT_USE_URING
sf_context->use_io_uring = (config->comm_type == fc_comm_type_sock);
sf_context->use_send_zc = sf_context->use_io_uring ? use_send_zc : false;
#else
sf_context->use_io_uring = false;
#endif
sf_context->accept_threads = iniGetIntValue(
config->ini_ctx.section_name,
"accept_threads", config->ini_ctx.context, 1);
if (sf_context->accept_threads <= 0) {
logError("file: "__FILE__", line: %d, "
"config file: %s, section: %s, item \"accept_threads\" "
"is invalid, value: %d <= 0!", __LINE__, config->
ini_ctx.filename, config->ini_ctx.section_name,
sf_context->accept_threads);
return EINVAL;
}
sf_context->work_threads = iniGetIntValue(
config->ini_ctx.section_name, "work_threads",
config->ini_ctx.context, config->default_work_threads);
if (sf_context->work_threads <= 0) {
logError("file: "__FILE__", line: %d, "
"config file: %s, section: %s, item \"work_threads\" "
"is invalid, value: %d <= 0!", __LINE__, config->
ini_ctx.filename, config->ini_ctx.section_name,
sf_context->work_threads);
return EINVAL;
}
if ((result=load_bind_address(sf_context, config)) != 0) {
return result;
}
if ((result=load_address_family(sf_context, config)) != 0) {
return result;
}
if ((result=load_network_parameters(&config->ini_ctx, config->
max_pkg_size_item_name, config->max_pkg_size_min_value,
fixed_buff_size, task_buffer_extra_size,
&sf_context->net_buffer_cfg)) != 0)
{
return result;
}
return 0;
}
int sf_alloc_rdma_pd(SFContext *sf_context,
FCAddressPtrArray *address_array)
{
SFAddressFamilyHandler *fh;
SFNetworkHandler *handler;
int i;
int result;
for (i=0; i<SF_ADDRESS_FAMILY_COUNT; i++) {
fh = sf_context->handlers + i;
if (fh->af == AF_UNSPEC) {
continue;
}
handler = fh->handlers + SF_RDMACM_NETWORK_HANDLER_INDEX;
if (handler->enabled) {
if ((handler->pd=fc_alloc_rdma_pd(handler->alloc_pd,
address_array, &result)) == NULL)
{
return result;
}
}
}
return 0;
}
void sf_set_address_family_by_ip(SFContext *sf_context,
FCAddressPtrArray *address_array)
{
SFAddressFamilyHandler *handler;
SFAddressFamilyHandler *hend;
FCAddressInfo **pp_addr;
FCAddressInfo **addr_end;
if (sf_context->address_family != sf_address_family_auto) {
return;
}
hend = sf_context->handlers + SF_ADDRESS_FAMILY_COUNT;
for (handler=sf_context->handlers; handler<hend; handler++) {
if (handler->af == AF_UNSPEC) {
continue;
}
if (*(handler->inner_bind_addr) == '\0' &&
*(handler->outer_bind_addr) == '\0')
{
handler->af = AF_UNSPEC;
}
}
addr_end = address_array->addrs + address_array->count;
for (pp_addr=address_array->addrs; pp_addr<addr_end; pp_addr++) {
if ((*pp_addr)->conn.af == AF_INET) {
sf_context->handlers[SF_IPV4_ADDRESS_FAMILY_INDEX].af = AF_INET;
} else {
sf_context->handlers[SF_IPV6_ADDRESS_FAMILY_INDEX].af = AF_INET6;
}
}
}
static void combine_bind_addr(char *bind_addr, const char *ip_addr)
{
char *p;
if (*bind_addr == '\0') {
p = bind_addr;
} else {
p = bind_addr + strlen(bind_addr);
*p++ = ',';
}
strcpy(p, ip_addr);
}
static const char *get_address_family_caption(
const SFAddressFamily address_family)
{
switch (address_family) {
case sf_address_family_auto:
return "auto";
case sf_address_family_ipv4:
return "IPv4";
case sf_address_family_ipv6:
return "IPv6";
case sf_address_family_both:
return "both";
default:
return "unkown";
}
}
void sf_context_config_to_string(const SFContext *sf_context,
char *output, const int size)
{
const SFAddressFamilyHandler *fh;
const SFNetworkHandler *sock_handler;
char inner_bind_addr[2 * IP_ADDRESS_SIZE + 2];
char outer_bind_addr[2 * IP_ADDRESS_SIZE + 2];
int i;
int len;
*inner_bind_addr = '\0';
*outer_bind_addr = '\0';
sock_handler = NULL;
for (i=0; i<SF_ADDRESS_FAMILY_COUNT; i++) {
fh = sf_context->handlers + i;
if (fh->af == AF_UNSPEC) {
continue;
}
if (*(fh->inner_bind_addr) != '\0') {
combine_bind_addr(inner_bind_addr, fh->inner_bind_addr);
}
if (*(fh->outer_bind_addr) != '\0') {
combine_bind_addr(outer_bind_addr, fh->outer_bind_addr);
}
sock_handler = fh->handlers + SF_SOCKET_NETWORK_HANDLER_INDEX;
}
len = 0;
if ((sock_handler->inner.port == sock_handler->outer.port) &&
(strcmp(inner_bind_addr, outer_bind_addr) == 0))
{
len += snprintf(output + len, size - len,
"port=%u, bind_addr=%s",
sock_handler->inner.port,
inner_bind_addr);
} else {
len += snprintf(output + len, size - len,
"inner_port=%u, inner_bind_addr=%s, "
"outer_port=%u, outer_bind_addr=%s",
sock_handler->inner.port, inner_bind_addr,
sock_handler->outer.port, outer_bind_addr);
}
len += snprintf(output + len, size - len,
", address_family=%s, accept_threads=%d, work_threads=%d",
get_address_family_caption(sf_context->address_family),
sf_context->accept_threads, sf_context->work_threads);
#if IOEVENT_USE_URING
len += snprintf(output + len, size - len, ", use_io_uring=%d, "
"use_send_zc=%d", sf_context->use_io_uring,
sf_context->use_send_zc);
#endif
}
void sf_log_config_to_string_ex(SFLogConfig *log_cfg, const char *caption,
const char *other_config, char *output, const int size)
{
snprintf(output, size,
"%s: {%s%ssync_log_buff_interval=%d, rotate_everyday=%d, "
"rotate_time=%02d:%02d, rotate_on_size=%"PRId64", "
"compress_old=%d, compress_days_before=%d, keep_days=%d, "
"delete_old_time=%02d:%02d}", caption,
other_config != NULL ? other_config : "",
other_config != NULL ? ", " : "",
log_cfg->sync_log_buff_interval, log_cfg->rotate_everyday,
log_cfg->rotate_time.hour, log_cfg->rotate_time.minute,
log_cfg->rotate_on_size, log_cfg->compress_old,
log_cfg->compress_days_before, log_cfg->keep_days,
log_cfg->delete_old_time.hour, log_cfg->delete_old_time.minute);
}
void sf_slow_log_config_to_string(SFSlowLogConfig *slow_log_cfg,
const char *caption, char *output, const int size)
{
int len;
char slow_log_buff[256];
len = snprintf(slow_log_buff, sizeof(slow_log_buff),
"enabled=%d", slow_log_cfg->enabled);
if (!slow_log_cfg->enabled) {
snprintf(output, size, "%s: {%s}",
caption, slow_log_buff);
return;
}
snprintf(slow_log_buff + len, sizeof(slow_log_buff) - len,
", filename_prefix=%s, log_slower_than_ms=%d",
slow_log_cfg->filename_prefix,
slow_log_cfg->log_slower_than_ms);
sf_log_config_to_string_ex(&slow_log_cfg->log_cfg, caption,
slow_log_buff, output, size);
}
void sf_global_config_to_string_ex(const char *max_pkg_size_item_nm,
char *output, const int size)
{
int len;
int max_pkg_size;
int min_buff_size;
int max_buff_size;
char pkg_buff[256];
max_pkg_size = g_sf_global_vars.net_buffer_cfg.max_pkg_size -
g_sf_global_vars.task_buffer_extra_size;
min_buff_size = g_sf_global_vars.net_buffer_cfg.min_buff_size -
g_sf_global_vars.task_buffer_extra_size;
max_buff_size = g_sf_global_vars.net_buffer_cfg.max_buff_size -
g_sf_global_vars.task_buffer_extra_size;
if (min_buff_size == max_buff_size && max_pkg_size == max_buff_size) {
snprintf(pkg_buff, sizeof(pkg_buff), "%s=%d KB",
max_pkg_size_item_nm, max_pkg_size / 1024);
} else {
snprintf(pkg_buff, sizeof(pkg_buff), "%s=%d KB, "
"min_buff_size=%d KB, max_buff_size=%d KB",
max_pkg_size_item_nm, max_pkg_size / 1024,
min_buff_size / 1024, max_buff_size / 1024);
}
len = snprintf(output, size,
"base_path=%s, max_connections=%d, connect_timeout=%d, "
"network_timeout=%d, thread_stack_size=%d KB, %s, ",
SF_G_BASE_PATH_STR,
g_sf_global_vars.net_buffer_cfg.max_connections,
g_sf_global_vars.net_buffer_cfg.connect_timeout,
g_sf_global_vars.net_buffer_cfg.network_timeout,
g_sf_global_vars.thread_stack_size / 1024, pkg_buff);
#if IOEVENT_USE_URING
len += snprintf(output + len, size - len, "use_io_uring=%d, "
"use_send_zc=%d, ", g_sf_context.use_io_uring,
g_sf_context.use_send_zc);
#endif
len += snprintf(output + len, size - len,
"tcp_quick_ack=%d, "
"log_level=%s, "
"run_by_group=%s, run_by_user=%s, ",
g_sf_global_vars.tcp_quick_ack,
log_get_level_caption(),
g_sf_global_vars.run_by.group,
g_sf_global_vars.run_by.user);
sf_log_config_to_string(&g_sf_global_vars.error_log,
"error-log", output + len, size - len);
}
void sf_log_config_ex(const char *other_config)
{
char sz_global_config[512];
char sz_context_config[128];
sf_global_config_to_string(sz_global_config, sizeof(sz_global_config));
if (!g_sf_context.is_client) {
sf_context_config_to_string(&g_sf_context, sz_context_config,
sizeof(sz_context_config));
} else {
*sz_context_config = '\0';
}
logInfo("%s%s%s%s%s", sz_global_config, (*sz_context_config != '\0') ?
", " : "", sz_context_config,
(other_config != NULL && *other_config != '\0') ? ", " : "",
(other_config != NULL) ? other_config : ""
);
}
int sf_load_data_path_config_ex(IniFullContext *ini_ctx,
const char *item_name, const char *default_value, string_t *path)
{
const char *data_path;
int data_path_len;
int path_size;
data_path = iniGetStrValue(ini_ctx->section_name,
item_name, ini_ctx->context);
if (data_path == NULL) {
data_path = default_value;
} else if (*data_path == '\0') {
logError("file: "__FILE__", line: %d, "
"config file: %s%s%s, empty %s! "
"please set %s correctly.", __LINE__,
ini_ctx->filename, ini_ctx->section_name != NULL ?
", section: " : "", ini_ctx->section_name != NULL ?
ini_ctx->section_name : "", item_name, item_name);
return EINVAL;
}
data_path_len = strlen(data_path);
if (*data_path == '/') {
path->len = data_path_len;
path->str = fc_strdup1(data_path, path->len);
if (path->str == NULL) {
return ENOMEM;
}
} else {
path_size = SF_G_BASE_PATH_LEN + data_path_len + 2;
path->str = (char *)fc_malloc(path_size);
if (path->str == NULL) {
return ENOMEM;
}
path->len = fc_get_full_filepath_ex(SF_G_BASE_PATH_STR,
SF_G_BASE_PATH_LEN, data_path, data_path_len,
path->str, path_size);
}
chopPath(path->str);
path->len = strlen(path->str);
if (access(path->str, F_OK) != 0) {
if (errno != ENOENT) {
logError("file: "__FILE__", line: %d, "
"access %s fail, errno: %d, error info: %s",
__LINE__, path->str, errno, STRERROR(errno));
return errno != 0 ? errno : EPERM;
}
if (mkdir(path->str, 0775) != 0) {
logError("file: "__FILE__", line: %d, "
"mkdir %s fail, errno: %d, error info: %s",
__LINE__, path->str, errno, STRERROR(errno));
return errno != 0 ? errno : EPERM;
}
SF_CHOWN_TO_RUNBY_RETURN_ON_ERROR(path->str);
}
return 0;
}
Reference in New Issue View Git Blame Copy Permalink