[SR-Dev] git:ser_core_cvs: tcp: enable runtime changing for most of the cfg vars

Module: sip-router Branch: ser_core_cvs Commit: c0c298d54baae3143a0113a0838fe05dcee7695d URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=c0c298d… Author: Andrei Pelinescu-Onciul &lt;andrei(a)iptel.org&gt; Committer: Andrei Pelinescu-Onciul &lt;andrei(a)iptel.org&gt; Date: Thu Mar 5 17:20:53 2009 +0000 tcp: enable runtime changing for most of the cfg vars - following tcp config variables can now be changes at runtime: connect_timeout, send_timeout, connection_lifetime, max_connections (can be decreased, it cannot be increased more then the startup value), conn_wq_max, wq_max, crlf_ping, accept_aliases, alias_flags, new_conn_alias_flags. - the following variables can be changes but they will affect only new connections opened by ser: delayed_ack, syncnt, linger2, keepalive, keepidle, keepintvl, keepcnt (for the ser.cfg equivalent, just add tcp_ in front of the variable name; for help and grep NEWS) - updated core.tcp_options to dump all the tcp config options --- core_cmd.c | 22 ++++++++---- tcp_options.c | 105 +++++++++++++++++++++++++++++++++++++++++++++----------- 2 files changed, 98 insertions(+), 29 deletions(-) diff --git a/core_cmd.c b/core_cmd.c index fdb66a0..ccac004 100644 --- a/core_cmd.c +++ b/core_cmd.c @@ -565,14 +565,17 @@ static void core_tcp_options(rpc_t* rpc, void* c) if (!tcp_disable){ tcp_options_get(&t); rpc->add(c, "{", &handle); - rpc->struct_add(handle, "ddddddddddddddd", + rpc->struct_add(handle, "dddddddddddddddddddddd", + "connect_timeout", t.connect_timeout_s, + "send_timeout", t.send_timeout_s, + "connection_lifetime", t.con_lifetime_s, + "max_connections(soft)", t.max_connections, "fd_cache", t.fd_cache, - "tcp_buf_write", t.tcp_buf_write, - "tcp_connect_wait", t.tcp_connect_wait, - "tcpconn_wq_max", t.tcpconn_wq_max, - "tcp_wq_max", t.tcp_wq_max, - "tcp_wq_timeout", TICKS_TO_S(t.tcp_wq_timeout), - + "async", t.tcp_buf_write, + "connect_wait", t.tcp_connect_wait, + "conn_wq_max", t.tcpconn_wq_max, + "wq_max", t.tcp_wq_max, + "wq_timeout", TICKS_TO_S(t.tcp_wq_timeout), "defer_accept", t.defer_accept, "delayed_ack", t.delayed_ack, "syncnt", t.syncnt, @@ -581,7 +584,10 @@ static void core_tcp_options(rpc_t* rpc, void* c) "keepidle", t.keepidle, "keepintvl", t.keepintvl, "keepcnt", t.keepcnt, - "crlf_ping", t.crlf_ping + "crlf_ping", t.crlf_ping, + "accept_aliases", t.accept_aliases, + "alias_flags", t.alias_flags, + "new_conn_alias_flags", t.new_conn_alias_flags ); }else{ rpc->fault(c, 500, "tcp support disabled"); diff --git a/tcp_options.c b/tcp_options.c index fa522a1..a292b01 100644 --- a/tcp_options.c +++ b/tcp_options.c @@ -65,20 +65,28 @@ struct cfg_group_tcp tcp_default_cfg; +static int fix_connect_to(void* cfg_h, str* name, void** val); +static int fix_send_to(void* cfg_h, str* name, void** val); +static int fix_con_lt(void* cfg_h, str* name, void** val); +static int fix_max_conns(void* cfg_h, str* name, void** val); + + + /* cfg_group_tcp description (for the config framework)*/ static cfg_def_t tcp_cfg_def[] = { /* name , type |input type| chg type, min, max, fixup, proc. cbk description */ - { "connect_timeout", CFG_VAR_INT | CFG_READONLY, -1, - TICKS_TO_S(MAX_TCP_CON_LIFETIME), 0, 0, + { "connect_timeout", CFG_VAR_INT | CFG_ATOMIC, -1, + TICKS_TO_S(MAX_TCP_CON_LIFETIME), fix_connect_to, 0, "used only in non-async mode, in seconds"}, - { "send_timeout", CFG_VAR_INT | CFG_READONLY, -1, - TICKS_TO_S(MAX_TCP_CON_LIFETIME), 0, 0, + { "send_timeout", CFG_VAR_INT | CFG_ATOMIC, -1, + TICKS_TO_S(MAX_TCP_CON_LIFETIME), fix_send_to, 0, "in seconds"}, - { "connection_lifetime", CFG_VAR_INT | CFG_READONLY, -1, - TICKS_TO_S(MAX_TCP_CON_LIFETIME), 0, 0, + { "connection_lifetime", CFG_VAR_INT | CFG_ATOMIC, -1, + TICKS_TO_S(MAX_TCP_CON_LIFETIME), fix_con_lt, 0, "connection lifetime (in seconds)"}, - { "max_connections", CFG_VAR_INT | CFG_READONLY, 0, (1U<<31)-1, 0, 0, + { "max_connections", CFG_VAR_INT | CFG_ATOMIC, 0, (1U<<31)-1, + fix_max_conns, 0, "maximum connection number, soft limit"}, { "fd_cache", CFG_VAR_INT | CFG_READONLY, 0, 1, 0, 0, "file descriptor cache for tcp_send"}, @@ -87,36 +95,36 @@ static cfg_def_t tcp_cfg_def[] = { "async mode for writes and connects"}, { "connect_wait", CFG_VAR_INT | CFG_READONLY, 0, 1, 0, 0, "parallel simultaneous connects to the same dst. (0) or one connect"}, - { "conn_wq_max", CFG_VAR_INT | CFG_READONLY, 0, 1024*1024, 0, 0, + { "conn_wq_max", CFG_VAR_INT | CFG_ATOMIC, 0, 1024*1024, 0, 0, "maximum bytes queued for write per connection (depends on async)"}, - { "wq_max", CFG_VAR_INT | CFG_READONLY, 0, 1<<30, 0, 0, + { "wq_max", CFG_VAR_INT | CFG_ATOMIC, 0, 1<<30, 0, 0, "maximum bytes queued for write allowed globally (depends on async)"}, /* see also wq_timeout below */ /* tcp socket options */ { "defer_accept", CFG_VAR_INT | CFG_READONLY, 0, 3600, 0, 0, "0/1 on linux, seconds on freebsd (see docs)"}, - { "delayed_ack", CFG_VAR_INT | CFG_READONLY, 0, 1, 0, 0, + { "delayed_ack", CFG_VAR_INT | CFG_ATOMIC, 0, 1, 0, 0, "initial ack will be delayed and sent with the first data segment"}, - { "syncnt", CFG_VAR_INT | CFG_READONLY, 0, 1, 0, 0, + { "syncnt", CFG_VAR_INT | CFG_ATOMIC, 0, 1024, 0, 0, "number of syn retransmissions before aborting a connect (0=not set)"}, - { "linger2", CFG_VAR_INT | CFG_READONLY, 0, 3600, 0, 0, + { "linger2", CFG_VAR_INT | CFG_ATOMIC, 0, 3600, 0, 0, "lifetime of orphaned sockets in FIN_WAIT2 state in s (0=not set)"}, - { "keepalive", CFG_VAR_INT | CFG_READONLY, 0, 1, 0, 0, + { "keepalive", CFG_VAR_INT | CFG_ATOMIC, 0, 1, 0, 0, "enables/disables keepalives for tcp"}, - { "keepidle", CFG_VAR_INT | CFG_READONLY, 0, 24*3600, 0, 0, + { "keepidle", CFG_VAR_INT | CFG_ATOMIC, 0, 24*3600, 0, 0, "time before sending a keepalive if the connection is idle (linux)"}, - { "keepintvl", CFG_VAR_INT | CFG_READONLY, 0, 24*3600, 0, 0, + { "keepintvl", CFG_VAR_INT | CFG_ATOMIC, 0, 24*3600, 0, 0, "time interval between keepalive probes on failure (linux)"}, - { "keepcnt", CFG_VAR_INT | CFG_READONLY, 0, 1<<10, 0, 0, + { "keepcnt", CFG_VAR_INT | CFG_ATOMIC, 0, 1<<10, 0, 0, "number of failed keepalives before dropping the connection (linux)"}, /* other options */ - { "crlf_ping", CFG_VAR_INT | CFG_READONLY, 0, 1, 0, 0, + { "crlf_ping", CFG_VAR_INT | CFG_ATOMIC, 0, 1, 0, 0, "enable responding to CRLF SIP-level keepalives "}, - { "accept_aliases", CFG_VAR_INT | CFG_READONLY, 0, 1, 0, 0, + { "accept_aliases", CFG_VAR_INT | CFG_ATOMIC, 0, 1, 0, 0, "turn on/off tcp aliases (see tcp_accept_aliases) "}, - { "alias_flags", CFG_VAR_INT | CFG_READONLY, 0, 0, 0, 0, + { "alias_flags", CFG_VAR_INT | CFG_ATOMIC, 0, 2, 0, 0, "flags used for adding new aliases (FORCE_ADD:1 , REPLACE:2) "}, - { "new_conn_alias_flags", CFG_VAR_INT | CFG_READONLY, 0, 0, 0, 0, + { "new_conn_alias_flags", CFG_VAR_INT | CFG_ATOMIC, 0, 2, 0, 0, "flags for the def. aliases for a new conn. (FORCE_ADD:1, REPLACE:2 "}, /* internal and/or "fixed" versions of some vars (not supposed to be writeable, read will provide only debugging value*/ @@ -203,6 +211,61 @@ static void fix_timeout(char* name, int* to, int default_val, unsigned max_val) +static int fix_connect_to(void* cfg_h, str* name, void** val) +{ + int v; + v=(int)(long)*val; + fix_timeout("tcp_connect_timeout", &v, DEFAULT_TCP_CONNECT_TIMEOUT, + TICKS_TO_S(MAX_TCP_CON_LIFETIME)); + *val=(void*)(long)v; + return 0; +} + + +static int fix_send_to(void* cfg_h, str* name, void** val) +{ + int v; + v=(int)(long)*val; + fix_timeout("tcp_send_timeout", &v, DEFAULT_TCP_SEND_TIMEOUT, + TICKS_TO_S(MAX_TCP_CON_LIFETIME)); + *val=(void*)(long)v; +#ifdef TCP_BUF_WRITE + ((struct cfg_group_tcp*)cfg_h)->tcp_wq_timeout=S_TO_TICKS(v); +#endif /* TCP_BUF_WRITE */ + return 0; +} + + +static int fix_con_lt(void* cfg_h, str* name, void** val) +{ + int v; + v=(int)(long)*val; + fix_timeout("tcp_connection_lifetime", &v, + TICKS_TO_S(MAX_TCP_CON_LIFETIME), + TICKS_TO_S(MAX_TCP_CON_LIFETIME)); + *val=(void*)(long)v; +#ifdef TCP_BUF_WRITE + ((struct cfg_group_tcp*)cfg_h)->con_lifetime=S_TO_TICKS(v); +#endif /* TCP_BUF_WRITE */ + return 0; +} + + +static int fix_max_conns(void* cfg_h, str* name, void** val) +{ + int v; + v=(int)(long)*val; + if (v>tcp_max_connections){ + INFO("cannot override hard tcp_max_connections limit, please" + " restart and increase tcp_max_connections in the cfg.\n"); + v=tcp_max_connections; + } + *val=(void*)(long)v; + return 0; +} + + + /* checks & warns if some tcp_option cannot be enabled */ void tcp_options_check() { @@ -276,7 +339,7 @@ void tcp_options_check() void tcp_options_get(struct cfg_group_tcp* t) { - *t=tcp_default_cfg; + *t=*(struct cfg_group_tcp*)tcp_cfg; }