src/bin/lttng-relayd/tcp_keep_alive.c

   1 /*
   2  * Copyright (C) 2017 - Jonathan Rajotte <jonathan.rajotte-julien@efficios.com>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License, version 2 only,
   6  * as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful, but WITHOUT
   9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  11  * more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along
  14  * with this program; if not, write to the Free Software Foundation, Inc.,
  15  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  16  */
  17
  18 #include <sys/types.h>
  19 #include <netinet/tcp.h>
  20 #include <stdbool.h>
  21 #include <sys/socket.h>
  22 #include <limits.h>
  23
  24 #include <common/compat/getenv.h>
  25 #include <common/time.h>
  26 #include <common/defaults.h>
  27 #include <common/config/session-config.h>
  28
  29 #include "tcp_keep_alive.h"
  30
  31 #define SOLARIS_IDLE_TIME_MIN_S 10
  32 #define SOLARIS_IDLE_TIME_MAX_S 864000 /* 10 days */
  33 #define SOLARIS_ABORT_THRESHOLD_MIN_S 1
  34 #define SOLARIS_ABORT_THRESHOLD_MAX_S 480 /* 8 minutes */
  35
  36 /* Per-platform definitions of TCP socket options. */
  37 #if defined (__linux__)
  38
  39 #define COMPAT_TCP_LEVEL SOL_TCP
  40 #define COMPAT_TCP_ABORT_THRESHOLD 0 /* Does not exist on linux. */
  41 #define COMPAT_TCP_KEEPIDLE TCP_KEEPIDLE
  42 #define COMPAT_TCP_KEEPINTVL TCP_KEEPINTVL
  43 #define COMPAT_TCP_KEEPCNT TCP_KEEPCNT
  44
  45 #elif defined (__sun__) /* ! defined (__linux__) */
  46
  47 #define COMPAT_TCP_LEVEL IPPROTO_TCP
  48
  49 #ifdef TCP_KEEPALIVE_THRESHOLD
  50 #define COMPAT_TCP_KEEPIDLE TCP_KEEPALIVE_THRESHOLD
  51 #else /* ! defined (TCP_KEEPALIVE_THRESHOLD) */
  52 #define COMPAT_TCP_KEEPIDLE 0
  53 #endif /* TCP_KEEPALIVE_THRESHOLD */
  54
  55 #ifdef TCP_KEEPALIVE_ABORT_THRESHOLD
  56 #define COMPAT_TCP_ABORT_THRESHOLD TCP_KEEPALIVE_ABORT_THRESHOLD
  57 #else /* ! defined (TCP_KEEPALIVE_ABORT_THRESHOLD) */
  58 #define COMPAT_TCP_ABORT_THRESHOLD 0
  59 #endif /* TCP_KEEPALIVE_ABORT_THRESHOLD */
  60
  61 #define COMPAT_TCP_KEEPINTVL 0 /* Does not exist on Solaris. */
  62 #define COMPAT_TCP_KEEPCNT 0 /* Does not exist on Solaris. */
  63
  64 #else /* ! defined (__linux__) && ! defined (__sun__) */
  65
  66 #define COMPAT_TCP_LEVEL 0
  67 #define COMPAT_TCP_ABORT_THRESHOLD 0
  68 #define COMPAT_TCP_KEEPIDLE 0
  69 #define COMPAT_TCP_KEEPINTVL 0
  70 #define COMPAT_TCP_KEEPCNT 0
  71
  72 #endif /* ! defined (__linux__) && ! defined (__sun__) */
  73
  74 struct tcp_keep_alive_support {
  75         /* TCP keep-alive is supported by this platform. */
  76         bool supported;
  77         /* Overriding idle-time per socket is supported by this platform. */
  78         bool idle_time_supported;
  79         /*
  80          * Overriding probe interval per socket is supported by this
  81          * platform.
  82          */
  83         bool probe_interval_supported;
  84         /*
  85          * Configuring max probe count per socket is supported by this
  86          * platform.
  87          */
  88         bool max_probe_count_supported;
  89         /* Overriding on a per-socket basis is supported by this platform. */
  90         bool abort_threshold_supported;
  91 };
  92
  93 struct tcp_keep_alive_config {
  94         /* Maps to the LTTNG_RELAYD_TCP_KEEP_ALIVE_ENV environment variable. */
  95         bool enabled;
  96         /*
  97          * Maps to the LTTNG_RELAYD_TCP_KEEP_ALIVE_IDLE_TIME_ENV environment
  98          * variable.
  99          */
 100         int idle_time;
 101         /*
 102          * Maps to the LTTNG_RELAYD_TCP_KEEP_ALIVE_PROBE_INTERVAL_ENV
 103          * environment variable.
 104          */
 105         int probe_interval;
 106         /*
 107          * Maps to the LTTNG_RELAYD_TCP_KEEP_ALIVE_MAX_PROBE_COUNT_ENV
 108          * environment variable.
 109          */
 110         int max_probe_count;
 111         /*
 112          * Maps to the LTTNG_RELAYD_TCP_KEEP_ALIVE_ABORT_THRESHOLD_ENV
 113          * environment variable.
 114          */
 115         int abort_threshold;
 116 };
 117
 118 static struct tcp_keep_alive_config config = {
 119         .enabled = false,
 120         .idle_time = -1,
 121         .probe_interval = -1,
 122         .max_probe_count = -1,
 123         .abort_threshold = -1
 124 };
 125
 126 static struct tcp_keep_alive_support support = {
 127         .supported = false,
 128         .idle_time_supported = false,
 129         .probe_interval_supported = false,
 130         .max_probe_count_supported = false,
 131         .abort_threshold_supported = false
 132 };
 133
 134 /*
 135  * Common parser for string to positive int conversion where the value must be
 136  * in range [-1, INT_MAX].
 137  *
 138  * Returns -2 on invalid value.
 139  */
 140 static
 141 int get_env_int(const char *env_var,
 142                 const char *value)
 143 {
 144         int ret;
 145         long tmp;
 146         char *endptr = NULL;
 147
 148         errno = 0;
 149         tmp = strtol(value, &endptr, 0);
 150         if (errno != 0) {
 151                 ERR("%s cannot be parsed.", env_var);
 152                 PERROR("errno for previous parsing failure");
 153                 ret = -2;
 154                 goto end;
 155         }
 156
 157         if (endptr == value || *endptr != '\0') {
 158             ERR("%s is not a valid number", env_var);
 159             ret = -1;
 160             goto end;
 161         }
 162
 163         if (tmp < -1) {
 164                 ERR("%s must be greater or equal to -1", env_var);
 165                 ret = -2;
 166                 goto end;
 167         }
 168         if (tmp > INT_MAX){
 169                 ERR("%s is too big. Maximum value is %d", env_var, INT_MAX);
 170                 ret = -2;
 171                 goto end;
 172         }
 173
 174         ret = (int) tmp;
 175 end:
 176         return ret;
 177 }
 178
 179 /*
 180  * Per-platform implementation of tcp_keep_alive_idle_time_modifier.
 181  * Returns -2 on invalid value.
 182  */
 183 #ifdef __sun__
 184
 185 static
 186 int convert_idle_time(int value)
 187 {
 188         int ret;
 189         unsigned int tmp_ms;
 190
 191         if (value == -1 || value == 0) {
 192                 /* Use system defaults */
 193                 ret = value;
 194                 goto end;
 195         }
 196
 197         if (value < 0) {
 198                 ERR("Invalid tcp keep-alive idle time (%i)", value);
 199                 ret = -2;
 200                 goto end;
 201         }
 202
 203         /*
 204          * Additional constraints for Solaris 11.
 205          * Minimum 10s, maximum 10 days. Defined by
 206          * https://docs.oracle.com/cd/E23824_01/html/821-1475/tcp-7p.html#REFMAN7tcp-7p
 207          */
 208         if ((value < SOLARIS_IDLE_TIME_MIN_S ||
 209                         value > SOLARIS_IDLE_TIME_MAX_S)) {
 210                 ERR("%s must be comprised between %d and %d inclusively on Solaris",
 211                                 DEFAULT_LTTNG_RELAYD_TCP_KEEP_ALIVE_IDLE_TIME_ENV,
 212                                 SOLARIS_IDLE_TIME_MIN_S,
 213                                 SOLARIS_IDLE_TIME_MAX_S);
 214                 ret = -2;
 215                 goto end;
 216         }
 217
 218         /* On Solaris idle time is given in milliseconds. */
 219         tmp_ms = ((unsigned int) value) * MSEC_PER_SEC;
 220         if ((value != 0 && (tmp_ms / ((unsigned int) value)) != MSEC_PER_SEC)
 221                         || tmp_ms > INT_MAX) {
 222                 /* Overflow. */
 223                 const int max_value = INT_MAX / MSEC_PER_SEC;
 224
 225                 ERR("%s is too big: maximum supported value is %d",
 226                                 DEFAULT_LTTNG_RELAYD_TCP_KEEP_ALIVE_IDLE_TIME_ENV,
 227                                 max_value);
 228                 ret = -2;
 229                 goto end;
 230         }
 231
 232         /* tmp_ms is >= 0 and <= INT_MAX. Cast is safe. */
 233         ret = (int) tmp_ms;
 234 end:
 235         return ret;
 236 }
 237
 238 #else /* ! defined(__sun__) */
 239
 240 static
 241 int convert_idle_time(int value)
 242 {
 243         return value;
 244 }
 245
 246 #endif /* ! defined(__sun__) */
 247
 248 /* Per-platform support of tcp_keep_alive functionality. */
 249 #if defined (__linux__)
 250
 251 static
 252 void tcp_keep_alive_init_support(struct tcp_keep_alive_support *support)
 253 {
 254         support->supported = true;
 255         support->idle_time_supported = true;
 256         support->probe_interval_supported = true;
 257         support->max_probe_count_supported = true;
 258         /* Solaris specific */
 259         support->abort_threshold_supported = false;
 260 }
 261
 262 #elif defined(__sun__) /* ! defined (__linux__) */
 263
 264 static
 265 void tcp_keep_alive_init_support(struct tcp_keep_alive_support *support)
 266 {
 267         support->supported = true;
 268 #ifdef TCP_KEEPALIVE_THRESHOLD
 269         support->idle_time_supported = true;
 270 #else
 271         support->idle_time_supported = false;;
 272 #endif /* TCP_KEEPALIVE_THRESHOLD */
 273
 274         /*
 275          * Solaris does not support either tcp_keepalive_probes or
 276          * tcp_keepalive_intvl.
 277          * Inferring a value for TCP_KEEP_ALIVE_ABORT_THRESHOLD using
 278          * (tcp_keepalive_probes * tcp_keepalive_intvl) could yield a good
 279          * alternative, but Solaris does not detail the algorithm used (such as
 280          * constant time retry like Linux).
 281          *
 282          * Ignore those settings on Solaris 11. We prefer exposing an
 283          * environment variable only used on Solaris for the abort threshold.
 284          */
 285         support->probe_interval_supported = false;
 286         support->max_probe_count_supported = false;
 287 #ifdef TCP_KEEPALIVE_ABORT_THRESHOLD
 288         support->abort_threshold_supported = true;
 289 #else
 290         support->abort_threshold_supported = false;
 291 #endif /* TCP_KEEPALIVE_THRESHOLD */
 292 }
 293
 294 #else /* ! defined(__sun__) && ! defined(__linux__) */
 295
 296 /* Assume nothing is supported on other platforms. */
 297 static
 298 void tcp_keep_alive_init_support(struct tcp_keep_alive_support *support)
 299 {
 300         support->supported = false;
 301         support->idle_time_supported = false;
 302         support->probe_interval_supported = false;
 303         support->max_probe_count_supported = false;
 304         support->abort_threshold_supported = false;
 305 }
 306
 307 #endif /* ! defined(__sun__) && ! defined(__linux__) */
 308
 309 #ifdef __sun__
 310
 311 /*
 312  * Solaris specific modifier for abort threshold.
 313  * Return -2 on error.
 314  */
 315 static
 316 int convert_abort_threshold(int value)
 317 {
 318         int ret;
 319         unsigned int tmp_ms;
 320
 321         if (value == -1) {
 322                 /* Use system defaults */
 323                 ret = value;
 324                 goto end;
 325         }
 326
 327         if (value < 0) {
 328                 ERR("Invalid tcp keep-alive abort threshold (%i)", value);
 329                 ret = -2;
 330                 goto end;
 331         }
 332
 333         /*
 334          * Additional constraints for Solaris 11.
 335          *
 336          * Between 0 and 8 minutes.
 337          * https://docs.oracle.com/cd/E19120-01/open.solaris/819-2724/fsvdh/index.html
 338          *
 339          * Restrict from 1 seconds to 8 minutes sice the 0 value goes against
 340          * the purpose of dead peers detection by never timing out when probing.
 341          * It does NOT mean that the connection times out immediately.
 342          */
 343         if ((value < SOLARIS_ABORT_THRESHOLD_MIN_S || value > SOLARIS_ABORT_THRESHOLD_MAX_S)) {
 344                 ERR("%s must be comprised between %d and %d inclusively on Solaris",
 345                                 DEFAULT_LTTNG_RELAYD_TCP_KEEP_ALIVE_ABORT_THRESHOLD_ENV,
 346                                 SOLARIS_ABORT_THRESHOLD_MIN_S,
 347                                 SOLARIS_ABORT_THRESHOLD_MAX_S);
 348                 ret = -2;
 349                 goto end;
 350         }
 351
 352         /* Abort threshold is given in milliseconds. */
 353         tmp_ms = ((unsigned int) value) * MSEC_PER_SEC;
 354         if ((value != 0 && (tmp_ms / ((unsigned int) value)) != MSEC_PER_SEC)
 355                         || tmp_ms > INT_MAX) {
 356                 /* Overflow */
 357                 const int max_value = INT_MAX / MSEC_PER_SEC;
 358
 359                 ERR("%s is too big: maximum supported value is %d",
 360                                 DEFAULT_LTTNG_RELAYD_TCP_KEEP_ALIVE_ABORT_THRESHOLD_ENV,
 361                                 max_value);
 362                 ret = -2;
 363                 goto end;
 364         }
 365
 366         /* tmp_ms is >= 0 and <= INT_MAX. Cast is safe. */
 367         ret = (int) tmp_ms;
 368 end:
 369         return ret;
 370 }
 371
 372 #else
 373
 374 static
 375 int convert_abort_threshold(int value)
 376 {
 377         return value;
 378 }
 379
 380 #endif /* defined (__sun__) */
 381
 382 /*
 383  * Retrieve settings from environment variables and warn for settings not
 384  * supported by the platform.
 385  */
 386 static
 387 int tcp_keep_alive_init_config(struct tcp_keep_alive_support *support,
 388                 struct tcp_keep_alive_config *config)
 389 {
 390         int ret;
 391         const char *value;
 392
 393         value = lttng_secure_getenv(DEFAULT_LTTNG_RELAYD_TCP_KEEP_ALIVE_ENV);
 394         if (!support->supported) {
 395                 if (value) {
 396                         WARN("Using per-socket TCP keep-alive mechanism is not supported by this platform. Ignoring the %s environment variable.",
 397                                         DEFAULT_LTTNG_RELAYD_TCP_KEEP_ALIVE_ENV);
 398                 }
 399                 config->enabled = false;
 400         } else if (value) {
 401                 ret = config_parse_value(value);
 402                 if (ret < 0 || ret > 1) {
 403                         ERR("Invalid value for %s", DEFAULT_LTTNG_RELAYD_TCP_KEEP_ALIVE_ENV);
 404                         ret = 1;
 405                         goto error;
 406                 }
 407                 config->enabled = ret;
 408         }
 409         DBG("TCP keep-alive mechanism %s", config->enabled ? "enabled": "disabled");
 410
 411         /* Get value for tcp_keepalive_time in seconds. */
 412         value = lttng_secure_getenv(DEFAULT_LTTNG_RELAYD_TCP_KEEP_ALIVE_IDLE_TIME_ENV);
 413         if (!support->idle_time_supported && value) {
 414                 WARN("Overriding the TCP keep-alive idle time threshold per-socket is not supported by this platform. Ignoring the %s environment variable.",
 415                                 DEFAULT_LTTNG_RELAYD_TCP_KEEP_ALIVE_IDLE_TIME_ENV);
 416                 config->idle_time = -1;
 417         } else if (value) {
 418                 int idle_time_platform;
 419                 int idle_time_seconds;
 420
 421                 idle_time_seconds = get_env_int(
 422                                 DEFAULT_LTTNG_RELAYD_TCP_KEEP_ALIVE_IDLE_TIME_ENV,
 423                                 value);
 424                 if (idle_time_seconds < -1) {
 425                         ret = 1;
 426                         goto error;
 427                 }
 428
 429                 idle_time_platform = convert_idle_time(idle_time_seconds);
 430                 if (idle_time_platform < -1) {
 431                         ret = 1;
 432                         goto error;
 433                 }
 434
 435                 config->idle_time = idle_time_platform;
 436                 DBG("Overriding %s to %d",
 437                                 DEFAULT_LTTNG_RELAYD_TCP_KEEP_ALIVE_IDLE_TIME_ENV,
 438                                 idle_time_seconds);
 439         }
 440
 441         /* Get value for tcp_keepalive_intvl in seconds. */
 442         value = lttng_secure_getenv(
 443                         DEFAULT_LTTNG_RELAYD_TCP_KEEP_ALIVE_PROBE_INTERVAL_ENV);
 444         if (!support->probe_interval_supported && value) {
 445                 WARN("Overriding the TCP keep-alive probe interval time per-socket is not supported by this platform. Ignoring the %s environment variable.",
 446                                 DEFAULT_LTTNG_RELAYD_TCP_KEEP_ALIVE_PROBE_INTERVAL_ENV);
 447                 config->probe_interval = -1;
 448         } else if (value) {
 449                 int probe_interval;
 450
 451                 probe_interval = get_env_int(DEFAULT_LTTNG_RELAYD_TCP_KEEP_ALIVE_PROBE_INTERVAL_ENV,
 452                                 value);
 453                 if (probe_interval < -1) {
 454                         ret = 1;
 455                         goto error;
 456                 }
 457
 458                 config->probe_interval = probe_interval;
 459                 DBG("Overriding %s to %d",
 460                                 DEFAULT_LTTNG_RELAYD_TCP_KEEP_ALIVE_PROBE_INTERVAL_ENV,
 461                                 config->probe_interval);
 462         }
 463
 464         /* Get value for tcp_keepalive_probes. */
 465         value = lttng_secure_getenv(DEFAULT_LTTNG_RELAYD_TCP_KEEP_ALIVE_MAX_PROBE_COUNT_ENV);
 466         if (!support->max_probe_count_supported && value) {
 467                 WARN("Overriding the TCP keep-alive maximum probe count per-socket is not supported by this platform. Ignoring the %s environment variable.",
 468                                  DEFAULT_LTTNG_RELAYD_TCP_KEEP_ALIVE_MAX_PROBE_COUNT_ENV);
 469                 config->max_probe_count = -1;
 470         } else if (value) {
 471                 int max_probe_count;
 472
 473                 max_probe_count = get_env_int(DEFAULT_LTTNG_RELAYD_TCP_KEEP_ALIVE_MAX_PROBE_COUNT_ENV,
 474                                 value);
 475                 if (max_probe_count < -1) {
 476                         ret = 1;
 477                         goto error;
 478                 }
 479
 480                 config->max_probe_count = max_probe_count;
 481                 DBG("Overriding %s to %d",
 482                                 DEFAULT_LTTNG_RELAYD_TCP_KEEP_ALIVE_MAX_PROBE_COUNT_ENV,
 483                                 config->max_probe_count);
 484         }
 485
 486         /* Get value for tcp_keepalive_abort_interval. */
 487         value = lttng_secure_getenv(
 488                         DEFAULT_LTTNG_RELAYD_TCP_KEEP_ALIVE_ABORT_THRESHOLD_ENV);
 489         if (!support->abort_threshold_supported && value) {
 490                 WARN("Overriding the TCP keep-alive abort threshold per-socket is not supported by this platform. Ignoring the %s environment variable.",
 491                                 DEFAULT_LTTNG_RELAYD_TCP_KEEP_ALIVE_ABORT_THRESHOLD_ENV);
 492                 config->abort_threshold = -1;
 493         } else if (value) {
 494                 int abort_threshold_platform;
 495                 int abort_threshold_seconds;
 496
 497                 abort_threshold_seconds = get_env_int(
 498                                 DEFAULT_LTTNG_RELAYD_TCP_KEEP_ALIVE_MAX_PROBE_COUNT_ENV,
 499                                 value);
 500                 if (abort_threshold_seconds < -1) {
 501                         ret = 1;
 502                         goto error;
 503                 }
 504
 505                 abort_threshold_platform = convert_abort_threshold(
 506                                 abort_threshold_seconds);
 507                 if (abort_threshold_platform < -1) {
 508                         ret = 1;
 509                         goto error;
 510                 }
 511
 512                 config->abort_threshold = abort_threshold_platform;
 513                 DBG("Overriding %s to %d",
 514                                 DEFAULT_LTTNG_RELAYD_TCP_KEEP_ALIVE_ABORT_THRESHOLD_ENV,
 515                                 config->abort_threshold);
 516         }
 517
 518         ret = 0;
 519
 520 error:
 521         return ret;
 522 }
 523
 524 /* Initialize the TCP keep-alive configuration. */
 525 __attribute__((constructor)) static
 526 int tcp_keep_alive_init(void)
 527 {
 528         tcp_keep_alive_init_support(&support);
 529         return tcp_keep_alive_init_config(&support, &config);
 530 }
 531
 532 /*
 533  * Set the socket options regarding TCP keep-alive.
 534  */
 535 LTTNG_HIDDEN
 536 int socket_apply_keep_alive_config(int socket_fd)
 537 {
 538         int ret;
 539         int val = 1;
 540
 541         /* TCP keep-alive */
 542         if (!support.supported || !config.enabled ) {
 543                 ret = 0;
 544                 goto end;
 545         }
 546
 547         DBG("TCP keep-alive enabled for socket %d", socket_fd);
 548         ret = setsockopt(socket_fd, SOL_SOCKET, SO_KEEPALIVE, &val,
 549                         sizeof(val));
 550         if (ret < 0) {
 551                 PERROR("setsockopt so_keepalive");
 552                 goto end;
 553         }
 554
 555         /* TCP keep-alive idle time */
 556         if (support.idle_time_supported && config.idle_time > 0) {
 557                 DBG("TCP keep-alive keep idle: %d enabled for socket %d", config.idle_time, socket_fd);
 558                 ret = setsockopt(socket_fd, COMPAT_TCP_LEVEL, COMPAT_TCP_KEEPIDLE, &config.idle_time,
 559                                 sizeof(config.idle_time));
 560                 if (ret < 0) {
 561                         PERROR("setsockopt TCP_KEEPIDLE");
 562                         goto end;
 563                 }
 564         }
 565         /* TCP keep-alive probe interval */
 566         if (support.probe_interval_supported && config.probe_interval > 0) {
 567                 DBG("TCP keep-alive probe_interval: %d enabled for socket %d", config.probe_interval, socket_fd);
 568                 ret = setsockopt(socket_fd, COMPAT_TCP_LEVEL, COMPAT_TCP_KEEPINTVL, &config.probe_interval,
 569                                 sizeof(config.probe_interval));
 570                 if (ret < 0) {
 571                         PERROR("setsockopt TCP_KEEPINTVL");
 572                         goto end;
 573                 }
 574         }
 575
 576         /* TCP keep-alive max probe count */
 577         if (support.max_probe_count_supported && config.max_probe_count > 0) {
 578                 DBG("TCP keep-alive max_probe: %d enabled for socket %d", config.max_probe_count, socket_fd);
 579                 ret = setsockopt(socket_fd, COMPAT_TCP_LEVEL, COMPAT_TCP_KEEPCNT, &config.max_probe_count,
 580                                 sizeof(config.max_probe_count));
 581                 if (ret < 0) {
 582                         PERROR("setsockopt TCP_KEEPCNT");
 583                         goto end;
 584                 }
 585         }
 586
 587         /* TCP keep-alive abort threshold */
 588         if (support.abort_threshold_supported && config.abort_threshold > 0) {
 589                 DBG("TCP keep-alive abort threshold: %d enabled for socket %d", config.abort_threshold, socket_fd);
 590                 ret = setsockopt(socket_fd, COMPAT_TCP_LEVEL, COMPAT_TCP_ABORT_THRESHOLD, &config.abort_threshold,
 591                                 sizeof(config.max_probe_count));
 592                 if (ret < 0) {
 593                         PERROR("setsockopt TCP_KEEPALIVE_ABORT_THRESHOLD");
 594                         goto end;
 595                 }
 596         }
 597 end:
 598         return ret;
 599 }