One Level Up Top Level

src/event/quic/ngx_event_quic_bpf.c - nginx-1.31.9 nginx/ @ 2a3a19c6f

Global variables defined

Data types defined

Functions defined

Macros defined

Source code


  2. /*
  3. * Copyright (C) Nginx, Inc.
  4. */


  7. #include <ngx_config.h>
  8. #include <ngx_core.h>
  9. #include <ngx_event.h>
  10. #include <ngx_event_quic_connection.h>


  13. ‌#define NGX_QUIC_BPF_VARNAME  "NGINX_BPF_MAPS"
  14. ‌#define NGX_QUIC_BPF_VARSEP    ';'
  15. ‌#define NGX_QUIC_BPF_ADDRSEP   '#'


  18. ‌#define ngx_quic_bpf_get_conf(cycle)                                          \
  19.     (ngx_quic_bpf_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_quic_bpf_module)

  21. ‌#define ngx_quic_bpf_get_old_conf(cycle)                                      \
  22.     cycle->old_cycle->conf_ctx ? ngx_quic_bpf_get_conf(cycle->old_cycle)      \
  23.                                : NULL

  25. ‌#define ngx_core_get_conf(cycle)                                              \
  26.     (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module)

  28. ‌#define ngx_quic_bpf_listen_key(worker)                                       \
  29.     (((uint64_t) 0xFF << 56)                                                  \
  30.      | ((uint64_t) (worker) & 0xFFFFFFFFFFFFULL))


  33. ‌typedef struct {
  34.     ngx_queue_t           queue;

  36.     int                   sock_map;
  37.     int                   worker_counts_map;

  39.     struct sockaddr      *sockaddr;
  40.     socklen_t             socklen;

  42.     ngx_array_t           listening;
  43. ‌} ngx_quic_sock_group_t;


  46. ‌typedef struct {
  47.     ngx_socket_t          fd;
  48.     uint64_t              key;
  49.     ngx_listening_t      *listening;
  50.     ngx_connection_t     *connection;
  51. ‌} ngx_quic_bpf_listening_t;


  54. ‌typedef struct {
  55.     ngx_flag_t            enabled;
  56.     ngx_uint_t            map_size;
  57.     ngx_uint_t            master_index;
  58.     u_char               *env;
  59.     ngx_queue_t           groups;     /* of ngx_quic_sock_group_t */
  60. ‌} ngx_quic_bpf_conf_t;


  63. static void *ngx_quic_bpf_create_conf(ngx_cycle_t *cycle);
  64. static char *ngx_quic_bpf_init_conf(ngx_cycle_t *cycle, void *conf);
  65. static ngx_int_t ngx_quic_bpf_module_init(ngx_cycle_t *cycle);
  66. static void ngx_quic_bpf_exit_master(ngx_cycle_t *cycle);

  68. static void ngx_quic_bpf_cleanup(void *data);
  69. static ngx_inline void ngx_quic_bpf_close(ngx_log_t *log, int fd,
  70.     const char *name);
  71. static ngx_inline ngx_int_t ngx_quic_bpf_map_update(ngx_log_t *log, int fd,
  72.     const void *key, const void *value, const char *name);

  74. static ngx_quic_sock_group_t *ngx_quic_bpf_find_group(ngx_quic_bpf_conf_t *bcf,
  75.     ngx_listening_t *ls);
  76. static ngx_quic_sock_group_t *ngx_quic_bpf_alloc_group(ngx_cycle_t *cycle,
  77.     ngx_listening_t *ls);
  78. static ngx_quic_sock_group_t *ngx_quic_bpf_create_group(ngx_cycle_t *cycle,
  79.     ngx_listening_t *ls);
  80. static ngx_int_t ngx_quic_bpf_inherit_fd(ngx_cycle_t *cycle, int fd);
  81. static ngx_quic_sock_group_t *ngx_quic_bpf_get_group(ngx_cycle_t *cycle,
  82.     ngx_listening_t *ls);
  83. static ngx_int_t ngx_quic_bpf_group_add_socket(ngx_cycle_t *cycle,
  84.     ngx_listening_t *ls);
  85. static ngx_int_t ngx_quic_bpf_add_worker_socket(ngx_cycle_t *cycle,
  86.     ngx_quic_sock_group_t *grp, ngx_listening_t *ls);
  87. static ngx_int_t ngx_quic_bpf_publish_workers(ngx_cycle_t *cycle,
  88.     ngx_quic_sock_group_t *grp, ngx_uint_t worker_count);

  90. static ngx_int_t ngx_quic_bpf_export_maps(ngx_cycle_t *cycle);
  91. static ngx_int_t ngx_quic_bpf_import_maps(ngx_cycle_t *cycle);

  93. extern ngx_bpf_program_t  ngx_quic_reuseport_helper;


  96. ‌static ngx_command_t  ngx_quic_bpf_commands[] = {

  98.     { ngx_string("quic_bpf"),
  99.       NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_FLAG,
  100.       ngx_conf_set_flag_slot,
  101.       0,
  102.       offsetof(ngx_quic_bpf_conf_t, enabled),
  103.       NULL },

  105.       ngx_null_command
  106. };


  109. ‌static ngx_core_module_t  ngx_quic_bpf_module_ctx = {
  110.     ngx_string("quic_bpf"),
  111.     ngx_quic_bpf_create_conf,
  112.     ngx_quic_bpf_init_conf
  113. };


  116. ‌ngx_module_t  ngx_quic_bpf_module = {
  117.     NGX_MODULE_V1,
  118.     &ngx_quic_bpf_module_ctx,              /* module context */
  119.     ngx_quic_bpf_commands,                 /* module directives */
  120.     NGX_CORE_MODULE,                       /* module type */
  121.     NULL,                                  /* init master */
  122.     ngx_quic_bpf_module_init,              /* init module */
  123.     NULL,                                  /* init process */
  124.     NULL,                                  /* init thread */
  125.     NULL,                                  /* exit thread */
  126.     NULL,                                  /* exit process */
  127.     ngx_quic_bpf_exit_master,              /* exit master */
  128.     NGX_MODULE_V1_PADDING
  129. };


  132. static void *
  133. ‌ngx_quic_bpf_create_conf(ngx_cycle_t *cycle)
  134. {
  135.     size_t                len;
  136.     u_char               *env;
  137.     ngx_quic_bpf_conf_t  *bcf;

  139.     bcf = ngx_pcalloc(cycle->pool, sizeof(ngx_quic_bpf_conf_t));
  140.     if (bcf == NULL) {
  141.         return NULL;
  142.     }

  144.     bcf->enabled = NGX_CONF_UNSET;
  145.     bcf->map_size = NGX_CONF_UNSET_UINT;

  147.     /*
  148.      * preserve environment variable value before it may be reset by
  149.      * some module, i.e. perl
  150.      */
  151.     env = (u_char *) getenv(NGX_QUIC_BPF_VARNAME);
  152.     if (env != NULL && *env != '\0') {
  153.         len = ngx_strlen(env);
  154.         bcf->env = ngx_pnalloc(cycle->pool, len + 1);
  155.         if (bcf->env == NULL) {
  156.             return NULL;
  157.         }

  159.         ngx_memcpy(bcf->env, env, len + 1);
  160.     }

  162.     ngx_queue_init(&bcf->groups);

  164.     return bcf;
  165. }


  168. static char *
  169. ‌ngx_quic_bpf_init_conf(ngx_cycle_t *cycle, void *conf)
  170. {
  171.     ngx_quic_bpf_conf_t  *bcf = conf;
  172.     ngx_quic_bpf_conf_t  *obcf;

  174.     ngx_conf_init_value(bcf->enabled, 0);

  176.     if (cycle->old_cycle->conf_ctx == NULL) {
  177.         return NGX_CONF_OK;
  178.     }

  180.     obcf = ngx_quic_bpf_get_conf(cycle->old_cycle);
  181.     if (obcf == NULL) {
  182.         return NGX_CONF_OK;
  183.     }

  185.     if (obcf->enabled != bcf->enabled) {
  186.         ngx_log_error(NGX_LOG_WARN, cycle->log, 0,
  187.                       "cannot change \"quic_bpf\" after reload, ignoring");
  188.         bcf->enabled = obcf->enabled;
  189.     }

  191.     bcf->master_index = obcf->master_index;

  193.     return NGX_CONF_OK;
  194. }


  197. static ngx_int_t
  198. ‌ngx_quic_bpf_module_init(ngx_cycle_t *cycle)
  199. {
  200.     ngx_uint_t              i;
  201.     ngx_queue_t            *q;
  202.     ngx_listening_t        *ls;
  203.     ngx_core_conf_t        *ccf;
  204.     ngx_pool_cleanup_t     *cln;
  205.     ngx_quic_bpf_conf_t    *bcf;
  206.     ngx_quic_sock_group_t  *grp;

  208.     if (ngx_test_config) {
  209.         /*
  210.          * during config test, SO_REUSEPORT socket option is
  211.          * not set, thus making further processing meaningless
  212.          */
  213.         return NGX_OK;
  214.     }

  216.     ccf = ngx_core_get_conf(cycle);
  217.     bcf = ngx_quic_bpf_get_conf(cycle);

  219.     if (!bcf->enabled) {

  221.         if (ngx_inherited && ngx_is_init_cycle(cycle->old_cycle)
  222.             && bcf->env != NULL)
  223.         {
  224.             ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
  225.                           "\"quic_bpf\" cannot be disabled "
  226.                           "during binary upgrade");
  227.             return NGX_ERROR;
  228.         }

  230.         return NGX_OK;
  231.     }

  233.     bcf->map_size = ccf->worker_processes * 32;

  235.     cln = ngx_pool_cleanup_add(cycle->pool, 0);
  236.     if (cln == NULL) {
  237.         goto failed;
  238.     }

  240.     cln->data = bcf;
  241.     cln->handler = ngx_quic_bpf_cleanup;

  243.     if (ngx_inherited && ngx_is_init_cycle(cycle->old_cycle)) {
  244.         if (ngx_quic_bpf_import_maps(cycle) != NGX_OK) {
  245.             goto failed;
  246.         }
  247.     }

  249.     ls = cycle->listening.elts;

  251.     for (i = 0; i < cycle->listening.nelts; i++) {
  252.         if (ls[i].quic && ls[i].reuseport) {
  253.             if (ngx_quic_bpf_group_add_socket(cycle, &ls[i]) != NGX_OK) {
  254.                 goto failed;
  255.             }
  256.         }
  257.     }

  259.     q = ngx_queue_head(&bcf->groups);

  261.     while (q != ngx_queue_sentinel(&bcf->groups)) {

  263.         grp = ngx_queue_data(q, ngx_quic_sock_group_t, queue);
  264.         q = ngx_queue_next(q);

  266.         if (grp->listening.nelts == 0) {

  268.             ngx_quic_bpf_close(cycle->log, grp->sock_map, "sockmap");
  269.             ngx_quic_bpf_close(cycle->log, grp->worker_counts_map,
  270.                                "worker_counts");
  271.             ngx_queue_remove(&grp->queue);
  272.             continue;
  273.         }

  275.         if (ngx_quic_bpf_publish_workers(cycle, grp, ccf->worker_processes)
  276.             != NGX_OK)
  277.         {
  278.             goto failed;
  279.         }
  280.     }

  282.     if (ngx_quic_bpf_export_maps(cycle) != NGX_OK) {
  283.         goto failed;
  284.     }

  286.     return NGX_OK;

  288. failed:

  290.     if (ngx_is_init_cycle(cycle->old_cycle)) {
  291.         ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
  292.                       "ngx_quic_bpf_module failed to initialize, check limits");

  294.         /* refuse to start */
  295.         return NGX_ERROR;
  296.     }

  298.     /*
  299.      * returning error now will lead to master process exiting immediately
  300.      * leaving worker processes orphaned, what is really unexpected.
  301.      * Instead, just issue a not about failed initialization and try
  302.      * to cleanup a bit. Still program can be already loaded to kernel
  303.      * for some reuseport groups, and there is no way to revert, so
  304.      * behaviour may be inconsistent.
  305.      */

  307.     ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
  308.                   "ngx_quic_bpf_module failed to initialize properly, ignored."
  309.                   "please check limits and note that nginx state now "
  310.                   "can be inconsistent and restart may be required");

  312.     return NGX_OK;
  313. }


  316. ngx_uint_t
  317. ‌ngx_quic_bpf_enabled(ngx_cycle_t *cycle)
  318. {
  319.     ngx_quic_bpf_conf_t  *bcf;

  321.     bcf = ngx_quic_bpf_get_conf(cycle);

  323.     if (bcf == NULL) {
  324.         return 0;
  325.     }

  327.     return bcf->enabled;
  328. }


  331. static void
  332. ‌ngx_quic_bpf_cleanup(void *data)
  333. {
  334.     ngx_quic_bpf_conf_t  *bcf = (ngx_quic_bpf_conf_t *) data;

  336.     ngx_uint_t                 i;
  337.     ngx_log_t                 *log;
  338.     ngx_queue_t               *q;
  339.     ngx_quic_sock_group_t     *grp;
  340.     ngx_quic_bpf_listening_t  *bls;

  342.     log = ngx_cycle->log;

  344.     for (q = ngx_queue_head(&bcf->groups);
  345.          q != ngx_queue_sentinel(&bcf->groups);
  346.          q = ngx_queue_next(q))
  347.     {
  348.         grp = ngx_queue_data(q, ngx_quic_sock_group_t, queue);

  350.         bls = grp->listening.elts;

  352.         for (i = 0; i < grp->listening.nelts; i++) {
  353.             if (bls[i].fd != (ngx_socket_t) -1) {
  354.                 if (ngx_close_socket(bls[i].fd) == -1) {
  355.                     ngx_log_error(NGX_LOG_ALERT, log, ngx_socket_errno,
  356.                                   ngx_close_socket_n " failed");
  357.                 }
  358.             }
  359.         }

  361.         ngx_quic_bpf_close(log, grp->sock_map, "sockmap");
  362.         ngx_quic_bpf_close(log, grp->worker_counts_map, "worker_counts");
  363.     }
  364. }


  367. static void
  368. ‌ngx_quic_bpf_exit_master(ngx_cycle_t *cycle)
  369. {
  370.     uint32_t                key, value;
  371.     ngx_queue_t            *q;
  372.     ngx_quic_bpf_conf_t    *bcf;
  373.     ngx_quic_sock_group_t  *grp;

  375.     bcf = ngx_quic_bpf_get_conf(cycle);
  376.     if (!bcf->enabled) {
  377.         return;
  378.     }

  380.     key = bcf->master_index;
  381.     value = 0;

  383.     for (q = ngx_queue_head(&bcf->groups);
  384.          q != ngx_queue_sentinel(&bcf->groups);
  385.          q = ngx_queue_next(q))
  386.     {
  387.         grp = ngx_queue_data(q, ngx_quic_sock_group_t, queue);

  389.         if (ngx_quic_bpf_map_update(cycle->log, grp->worker_counts_map,
  390.                                     &key, &value, "worker_counts")
  391.             != NGX_OK)
  392.         {
  393.             continue;
  394.         }
  395.     }
  396. }


  399. static ngx_inline void
  400. ‌ngx_quic_bpf_close(ngx_log_t *log, int fd, const char *name)
  401. {
  402.     if (fd == -1) {
  403.         return;
  404.     }

  406.     if (close(fd) != -1) {
  407.         return;
  408.     }

  410.     ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,
  411.                   "quic bpf close %s fd:%d failed", name, fd);
  412. }


  415. static ngx_inline ngx_int_t
  416. ‌ngx_quic_bpf_map_update(ngx_log_t *log, int fd, const void *key,
  417.     const void *value, const char *name)
  418. {
  419.     if (ngx_bpf_map_update(fd, key, value, BPF_ANY) != -1) {
  420.         return NGX_OK;
  421.     }

  423.     ngx_log_error(NGX_LOG_ERR, log, ngx_errno,
  424.                   "quic bpf failed to update %s map fd:%d", name, fd);

  426.     return NGX_ERROR;
  427. }


  430. static ngx_quic_sock_group_t *
  431. ‌ngx_quic_bpf_find_group(ngx_quic_bpf_conf_t *bcf, ngx_listening_t *ls)
  432. {
  433.     ngx_queue_t            *q;
  434.     ngx_quic_sock_group_t  *grp;

  436.     for (q = ngx_queue_head(&bcf->groups);
  437.          q != ngx_queue_sentinel(&bcf->groups);
  438.          q = ngx_queue_next(q))
  439.     {
  440.         grp = ngx_queue_data(q, ngx_quic_sock_group_t, queue);

  442.         if (ngx_cmp_sockaddr(ls->sockaddr, ls->socklen,
  443.                              grp->sockaddr, grp->socklen, 1)
  444.             == NGX_OK)
  445.         {
  446.             return grp;
  447.         }
  448.     }

  450.     return NULL;
  451. }


  454. static ngx_quic_sock_group_t *
  455. ‌ngx_quic_bpf_alloc_group(ngx_cycle_t *cycle, ngx_listening_t *ls)
  456. {
  457.     ngx_quic_bpf_conf_t    *bcf;
  458.     ngx_quic_sock_group_t  *grp;

  460.     bcf = ngx_quic_bpf_get_conf(cycle);

  462.     grp = ngx_pcalloc(cycle->pool, sizeof(ngx_quic_sock_group_t));
  463.     if (grp == NULL) {
  464.         return NULL;
  465.     }

  467.     grp->sock_map = -1;
  468.     grp->worker_counts_map = -1;

  470.     grp->sockaddr = ls->sockaddr;
  471.     grp->socklen = ls->socklen;

  473.     if (ngx_array_init(&grp->listening, cycle->pool, 1,
  474.                        sizeof(ngx_quic_bpf_listening_t))
  475.         != NGX_OK)
  476.     {
  477.         return NULL;
  478.     }

  480.     ngx_queue_insert_tail(&bcf->groups, &grp->queue);

  482.     return grp;
  483. }


  486. static ngx_quic_sock_group_t *
  487. ‌ngx_quic_bpf_create_group(ngx_cycle_t *cycle, ngx_listening_t *ls)
  488. {
  489.     int                     progfd, failed;
  490.     ngx_quic_bpf_conf_t    *bcf;
  491.     ngx_quic_sock_group_t  *grp;

  493.     bcf = ngx_quic_bpf_get_conf(cycle);

  495.     grp = ngx_quic_bpf_alloc_group(cycle, ls);
  496.     if (grp == NULL) {
  497.         return NULL;
  498.     }

  500.     grp->sock_map = ngx_bpf_map_create(cycle->log,
  501.                                        BPF_MAP_TYPE_SOCKHASH,
  502.                                        sizeof(uint64_t),
  503.                                        sizeof(uint64_t),
  504.                                        bcf->map_size, 0);
  505.     if (grp->sock_map == -1) {
  506.         goto failed;
  507.     }

  509.     if (ngx_quic_bpf_inherit_fd(cycle, grp->sock_map) != NGX_OK) {
  510.         goto failed;
  511.     }

  513.     ngx_bpf_program_link(&ngx_quic_reuseport_helper,
  514.                          "ngx_quic_sockmap", grp->sock_map);

  516.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  517.                    "quic bpf sockmap created fd:%d",
  518.                    grp->sock_map);

  520.     grp->worker_counts_map = ngx_bpf_map_create(cycle->log,
  521.                                                 BPF_MAP_TYPE_ARRAY,
  522.                                                 sizeof(uint32_t),
  523.                                                 sizeof(uint32_t), 2, 0);
  524.     if (grp->worker_counts_map == -1) {
  525.         goto failed;
  526.     }

  528.     if (ngx_quic_bpf_inherit_fd(cycle, grp->worker_counts_map) != NGX_OK) {
  529.         goto failed;
  530.     }

  532.     ngx_bpf_program_link(&ngx_quic_reuseport_helper,
  533.                          "ngx_quic_worker_counts", grp->worker_counts_map);

  535.     progfd = ngx_bpf_load_program(cycle->log, &ngx_quic_reuseport_helper);
  536.     if (progfd < 0) {
  537.         goto failed;
  538.     }

  540.     failed = 0;

  542.     if (setsockopt(ls->fd, SOL_SOCKET, SO_ATTACH_REUSEPORT_EBPF,
  543.                    &progfd, sizeof(int))
  544.         == -1)
  545.     {
  546.         ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_socket_errno,
  547.                       "quic bpf setsockopt(SO_ATTACH_REUSEPORT_EBPF) failed");
  548.         failed = 1;
  549.     }

  551.     ngx_quic_bpf_close(cycle->log, progfd, "program");

  553.     if (failed) {
  554.         goto failed;
  555.     }

  557.     return grp;

  559. failed:

  561.     ngx_quic_bpf_close(cycle->log, grp->sock_map, "sockmap");
  562.     ngx_quic_bpf_close(cycle->log, grp->worker_counts_map, "worker_counts");

  564.     ngx_queue_remove(&grp->queue);

  566.     return NULL;
  567. }


  570. static ngx_int_t
  571. ‌ngx_quic_bpf_inherit_fd(ngx_cycle_t *cycle, int fd)
  572. {
  573.     int  flags;

  575.     flags = fcntl(fd, F_GETFD);
  576.     if (flags == -1) {
  577.         ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  578.                       "quic bpf fcntl(F_GETFD) failed");
  579.         return NGX_ERROR;
  580.     }

  582.     flags &= ~FD_CLOEXEC;

  584.     if (fcntl(fd, F_SETFD, flags) == -1) {
  585.         ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  586.                       "quic bpf fcntl(F_SETFD) failed");
  587.         return NGX_ERROR;
  588.     }

  590.     return NGX_OK;
  591. }


  594. static ngx_quic_sock_group_t *
  595. ‌ngx_quic_bpf_get_group(ngx_cycle_t *cycle, ngx_listening_t *ls)
  596. {
  597.     ngx_quic_bpf_conf_t    *bcf, *old_bcf;
  598.     ngx_quic_sock_group_t  *grp, *ogrp;

  600.     bcf = ngx_quic_bpf_get_conf(cycle);

  602.     grp = ngx_quic_bpf_find_group(bcf, ls);
  603.     if (grp) {
  604.         return grp;
  605.     }

  607.     old_bcf = ngx_quic_bpf_get_old_conf(cycle);

  609.     if (old_bcf == NULL) {
  610.         return ngx_quic_bpf_create_group(cycle, ls);
  611.     }

  613.     ogrp = ngx_quic_bpf_find_group(old_bcf, ls);
  614.     if (ogrp == NULL) {
  615.         return ngx_quic_bpf_create_group(cycle, ls);
  616.     }

  618.     grp = ngx_quic_bpf_alloc_group(cycle, ls);
  619.     if (grp == NULL) {
  620.         return NULL;
  621.     }

  623.     grp->sock_map = dup(ogrp->sock_map);
  624.     if (grp->sock_map == -1) {
  625.         ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  626.                       "quic bpf failed to duplicate sockmap");
  627.         goto failed;
  628.     }

  630.     grp->worker_counts_map = dup(ogrp->worker_counts_map);
  631.     if (grp->worker_counts_map == -1) {
  632.         ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  633.                       "quic bpf failed to duplicate worker counts map");
  634.         goto failed;
  635.     }

  637.     return grp;

  639. failed:

  641.     ngx_quic_bpf_close(cycle->log, grp->sock_map, "sockmap");
  642.     ngx_quic_bpf_close(cycle->log, grp->worker_counts_map, "worker_counts");

  644.     ngx_queue_remove(&grp->queue);

  646.     return NULL;
  647. }


  650. static ngx_int_t
  651. ‌ngx_quic_bpf_group_add_socket(ngx_cycle_t *cycle, ngx_listening_t *ls)
  652. {
  653.     uint64_t                key, value;
  654.     ngx_quic_sock_group_t  *grp;

  656.     grp = ngx_quic_bpf_get_group(cycle, ls);
  657.     if (grp == NULL) {
  658.         return NGX_ERROR;
  659.     }

  661.     if (ngx_quic_bpf_add_worker_socket(cycle, grp, ls) != NGX_OK) {
  662.         return NGX_ERROR;
  663.     }

  665.     key = ngx_quic_bpf_listen_key(ls->worker);
  666.     value = ls->fd;

  668.     if (ngx_quic_bpf_map_update(cycle->log, grp->sock_map,
  669.                                 &key, &value, "listen")
  670.         != NGX_OK)
  671.     {
  672.         return NGX_ERROR;
  673.     }

  675.     return NGX_OK;
  676. }


  679. static ngx_int_t
  680. ‌ngx_quic_bpf_publish_workers(ngx_cycle_t *cycle, ngx_quic_sock_group_t *grp,
  681.     ngx_uint_t worker_count)
  682. {
  683.     uint32_t              key;
  684.     uint32_t              value;
  685.     ngx_quic_bpf_conf_t  *bcf;

  687.     bcf = ngx_quic_bpf_get_conf(cycle);

  689.     key = bcf->master_index;
  690.     value = worker_count;

  692.     if (ngx_quic_bpf_map_update(cycle->log, grp->worker_counts_map,
  693.                                 &key, &value, "worker_counts")
  694.         != NGX_OK)
  695.     {
  696.         return NGX_ERROR;
  697.     }

  699.     return NGX_OK;
  700. }


  703. static ngx_int_t
  704. ‌ngx_quic_bpf_add_worker_socket(ngx_cycle_t *cycle, ngx_quic_sock_group_t *grp,
  705.     ngx_listening_t *ls)
  706. {
  707.     int                        value;
  708.     uint64_t                   key, map_value;
  709.     ngx_uint_t                 i, n, map_updated;
  710.     ngx_socket_t               s;
  711.     ngx_quic_bpf_listening_t  *bls;

  713.     s = ngx_socket(ls->sockaddr->sa_family, SOCK_DGRAM, 0);
  714.     if (s == (ngx_socket_t) -1) {
  715.         ngx_log_error(NGX_LOG_ERR, cycle->log, ngx_socket_errno,
  716.                       "quic bpf " ngx_socket_n " failed");
  717.         return NGX_ERROR;
  718.     }

  720.     map_updated = 0;

  722.     if (ngx_nonblocking(s) == -1) {
  723.         ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  724.                       "quic bpf " ngx_nonblocking_n " failed");
  725.         goto failed;
  726.     }

  728.     if (fcntl(s, F_SETFD, FD_CLOEXEC) == -1) {
  729.         ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  730.                       "quic bpf fcntl(FD_CLOEXEC) failed");
  731.         goto failed;
  732.     }

  734.     value = 1;

  736.     if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR,
  737.                    (const void *) &value, sizeof(int))
  738.         == -1)
  739.     {
  740.         ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  741.                       "quic bpf setsockopt(SO_REUSEADDR) failed");
  742.         goto failed;
  743.     }

  745.     if (setsockopt(s, SOL_SOCKET, SO_REUSEPORT,
  746.                    (const void *) &value, sizeof(int))
  747.         == -1)
  748.     {
  749.         ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  750.                       "quic bpf setsockopt(SO_REUSEPORT) failed");
  751.         goto failed;
  752.     }

  754.     if (ls->rcvbuf != -1) {
  755.         if (setsockopt(s, SOL_SOCKET, SO_RCVBUF,
  756.                        (const void *) &ls->rcvbuf, sizeof(int))
  757.             == -1)
  758.         {
  759.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  760.                           "quic bpf setsockopt(SO_RCVBUF, %d) failed",
  761.                           ls->rcvbuf);
  762.             goto failed;
  763.         }
  764.     }

  766.     if (ls->sndbuf != -1) {
  767.         if (setsockopt(s, SOL_SOCKET, SO_SNDBUF,
  768.                        (const void *) &ls->sndbuf, sizeof(int))
  769.             == -1)
  770.         {
  771.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  772.                           "quic bpf setsockopt(SO_SNDBUF, %d) failed",
  773.                           ls->sndbuf);
  774.             goto failed;
  775.         }
  776.     }

  778. #if (NGX_HAVE_IP_PKTINFO)
  779.     if (ls->wildcard && ls->sockaddr->sa_family == AF_INET) {
  780.         if (setsockopt(s, IPPROTO_IP, IP_PKTINFO,
  781.                        (const void *) &value, sizeof(int))
  782.             == -1)
  783.         {
  784.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  785.                           "quic bpf setsockopt(IP_PKTINFO) failed");
  786.             goto failed;
  787.         }
  788.     }
  789. #endif

  791. #if (NGX_HAVE_INET6 && NGX_HAVE_IPV6_RECVPKTINFO)
  792.     if (ls->wildcard && ls->sockaddr->sa_family == AF_INET6) {
  793.         if (setsockopt(s, IPPROTO_IPV6, IPV6_RECVPKTINFO,
  794.                        (const void *) &value, sizeof(int))
  795.             == -1)
  796.         {
  797.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  798.                           "quic bpf setsockopt(IPV6_RECVPKTINFO) failed");
  799.             goto failed;
  800.         }
  801.     }
  802. #endif

  804. #if (NGX_HAVE_INET6 && defined IPV6_V6ONLY)

  806.     if (ls->sockaddr->sa_family == AF_INET6) {
  807.         int  ipv6only;

  809.         ipv6only = ls->ipv6only;

  811.         if (setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY,
  812.                        (const void *) &ipv6only, sizeof(int))
  813.             == -1)
  814.         {
  815.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  816.                           "quic bpf setsockopt(IPV6_V6ONLY) %V failed",
  817.                           &ls->addr_text);
  818.             goto failed;
  819.         }
  820.     }

  822. #endif

  824. #if (NGX_HAVE_IP_MTU_DISCOVER)

  826.     if (ls->sockaddr->sa_family == AF_INET) {
  827.         value = IP_PMTUDISC_DO;

  829.         if (setsockopt(s, IPPROTO_IP, IP_MTU_DISCOVER,
  830.                        (const void *) &value, sizeof(int))
  831.             == -1)
  832.         {
  833.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  834.                           "quic bpf setsockopt(IP_MTU_DISCOVER) "
  835.                           "failed, ignored");
  836.         }
  837.     }

  839. #elif (NGX_HAVE_IP_DONTFRAG)

  841.     if (ls->sockaddr->sa_family == AF_INET) {
  842.         value = 1;

  844.         if (setsockopt(s, IPPROTO_IP, IP_DONTFRAG,
  845.                        (const void *) &value, sizeof(int))
  846.             == -1)
  847.         {
  848.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  849.                           "quic bpf setsockopt(IP_DONTFRAG) "
  850.                           "failed, ignored");
  851.         }
  852.     }

  854. #endif

  856. #if (NGX_HAVE_INET6)

  858. #if (NGX_HAVE_IPV6_MTU_DISCOVER)

  860.     if (ls->sockaddr->sa_family == AF_INET6) {
  861.         value = IPV6_PMTUDISC_DO;

  863.         if (setsockopt(s, IPPROTO_IPV6, IPV6_MTU_DISCOVER,
  864.                        (const void *) &value, sizeof(int))
  865.             == -1)
  866.         {
  867.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  868.                           "quic bpf setsockopt(IPV6_MTU_DISCOVER) "
  869.                           "failed, ignored");
  870.         }
  871.     }

  873. #elif (NGX_HAVE_IPV6_DONTFRAG)

  875.     if (ls->sockaddr->sa_family == AF_INET6) {
  876.         value = 1;

  878.         if (setsockopt(s, IPPROTO_IPV6, IPV6_DONTFRAG,
  879.                        (const void *) &value, sizeof(int))
  880.             == -1)
  881.         {
  882.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  883.                           "quic bpf setsockopt(IPV6_DONTFRAG) "
  884.                           "failed, ignored");
  885.         }
  886.     }

  888. #endif

  890. #endif

  892.     if (bind(s, ls->sockaddr, ls->socklen) == -1) {
  893.         ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  894.                       "quic bpf bind() failed");
  895.         goto failed;
  896.     }

  898.     if (RAND_bytes((u_char *) &key, sizeof(uint64_t)) != 1) {
  899.         ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
  900.                       "quic bpf RAND_bytes() failed");
  901.         goto failed;
  902.     }

  904.     if ((key >> 56) == 0xFF) {
  905.         key &= ~((uint64_t) 0xFF << 56);
  906.     }

  908.     map_value = s;
  909.     if (ngx_quic_bpf_map_update(cycle->log, grp->sock_map,
  910.                                 &key, &map_value, "sockmap")
  911.         != NGX_OK)
  912.     {
  913.         goto failed;
  914.     }

  916.     map_updated = 1;

  918.     if (ls->worker >= grp->listening.nelts) {
  919.         n = ls->worker + 1 - grp->listening.nelts;

  921.         bls = ngx_array_push_n(&grp->listening, n);
  922.         if (bls == NULL) {
  923.             goto failed;
  924.         }

  926.         ngx_memzero(bls, n * sizeof(ngx_quic_bpf_listening_t));

  928.         for (i = 0; i < n; i++) {
  929.             bls[i].fd = (ngx_socket_t) -1;
  930.         }
  931.     }

  933.     bls = grp->listening.elts;
  934.     bls[ls->worker].fd = s;
  935.     bls[ls->worker].key = key;
  936.     bls[ls->worker].listening = ls;

  938.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  939.                    "quic bpf socket fd:%d key:%uL", s, key);

  941.     return NGX_OK;

  943. failed:

  945.     if (map_updated) {
  946.         if (ngx_bpf_map_delete(grp->sock_map, &key) == -1) {
  947.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  948.                           "quic bpf failed to delete map entry");
  949.         }
  950.     }

  952.     if (ngx_close_socket(s) == -1) {
  953.         ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
  954.                       "quic bpf " ngx_close_socket_n " failed");
  955.     }

  957.     return NGX_ERROR;
  958. }


  961. static ngx_int_t
  962. ‌ngx_quic_bpf_export_maps(ngx_cycle_t *cycle)
  963. {
  964.     u_char                 *p, *buf;
  965.     size_t                  len;
  966.     ngx_str_t              *var;
  967.     ngx_queue_t            *q;
  968.     ngx_core_conf_t        *ccf;
  969.     ngx_quic_bpf_conf_t    *bcf;
  970.     ngx_quic_sock_group_t  *grp;

  972.     ccf = ngx_core_get_conf(cycle);
  973.     bcf = ngx_quic_bpf_get_conf(cycle);
  974.     if (!bcf->enabled) {
  975.         return NGX_OK;
  976.     }

  978.     if (ngx_queue_empty(&bcf->groups)) {
  979.         return NGX_OK;
  980.     }

  982.     len = sizeof(NGX_QUIC_BPF_VARNAME) + 1;

  984.     for (q = ngx_queue_head(&bcf->groups);
  985.          q != ngx_queue_sentinel(&bcf->groups);
  986.          q = ngx_queue_next(q))
  987.     {
  988.         len += (NGX_INT32_LEN + 1) * 2 + NGX_SOCKADDR_STRLEN + 1;
  989.     }

  991.     len++;

  993.     buf = ngx_palloc(cycle->pool, len);
  994.     if (buf == NULL) {
  995.         return NGX_ERROR;
  996.     }

  998.     p = ngx_cpymem(buf, NGX_QUIC_BPF_VARNAME "=",
  999.                    sizeof(NGX_QUIC_BPF_VARNAME));

  1001.     *p++ = bcf->master_index ? '-' : '+';

  1003.     for (q = ngx_queue_head(&bcf->groups);
  1004.          q != ngx_queue_sentinel(&bcf->groups);
  1005.          q = ngx_queue_next(q))
  1006.     {
  1007.         grp = ngx_queue_data(q, ngx_quic_sock_group_t, queue);

  1009.         p = ngx_sprintf(p, "%ud", grp->sock_map);
  1010.         *p++ = NGX_QUIC_BPF_ADDRSEP;

  1012.         p = ngx_sprintf(p, "%ud", grp->worker_counts_map);
  1013.         *p++ = NGX_QUIC_BPF_ADDRSEP;

  1015.         p += ngx_sock_ntop(grp->sockaddr, grp->socklen, p,
  1016.                            NGX_SOCKADDR_STRLEN, 1);

  1018.         *p++ = NGX_QUIC_BPF_VARSEP;
  1019.     }

  1021.     *p = '\0';

  1023.     var = ngx_array_push(&ccf->env);
  1024.     if (var == NULL) {
  1025.         return NGX_ERROR;
  1026.     }

  1028.     var->data = buf;
  1029.     var->len = sizeof(NGX_QUIC_BPF_VARNAME) - 1;

  1031.     return NGX_OK;
  1032. }


  1035. static ngx_int_t
  1036. ‌ngx_quic_bpf_import_maps(ngx_cycle_t *cycle)
  1037. {
  1038.     int                     fds[2];
  1039.     u_char                 *inherited, *p, *v;
  1040.     ngx_int_t               fd;
  1041.     ngx_uint_t              i, nfd;
  1042.     ngx_addr_t              tmp;
  1043.     ngx_quic_bpf_conf_t    *bcf;
  1044.     ngx_quic_sock_group_t  *grp;

  1046.     bcf = ngx_quic_bpf_get_conf(cycle);
  1047.     inherited = bcf->env;

  1049.     if (inherited == NULL) {
  1050.         return NGX_OK;
  1051.     }

  1053.     nfd = 0;

  1055.     ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0,
  1056.                   "quic bpf using inherited QUIC BPF maps from \"%s\"",
  1057.                   inherited);

  1059.     switch (*inherited) {

  1061.     case '+':
  1062.         bcf->master_index = 1;
  1063.         break;

  1065.     case '-':
  1066.         bcf->master_index = 0;
  1067.         break;

  1069.     default:
  1070.         goto failed;
  1071.     }

  1073.     for (p = inherited + 1, v = p; *p; p++) {

  1075.         switch (*p) {

  1077.         case NGX_QUIC_BPF_ADDRSEP:

  1079.             if (nfd > 1) {
  1080.                 goto failed;
  1081.             }

  1083.             fd = ngx_atoi(v, p - v);
  1084.             if (fd == NGX_ERROR) {
  1085.                 goto failed;
  1086.             }

  1088.             fds[nfd++] = fd;
  1089.             v = p + 1;
  1090.             break;

  1092.         case NGX_QUIC_BPF_VARSEP:

  1094.             if (nfd != 2) {
  1095.                 goto failed;
  1096.             }

  1098.             grp = ngx_pcalloc(cycle->pool, sizeof(ngx_quic_sock_group_t));
  1099.             if (grp == NULL) {
  1100.                 goto failed;
  1101.             }

  1103.             if (ngx_array_init(&grp->listening, cycle->pool, 1,
  1104.                                sizeof(ngx_quic_bpf_listening_t))
  1105.                 != NGX_OK)
  1106.             {
  1107.                 goto failed;
  1108.             }

  1110.             grp->sock_map = fds[0];
  1111.             grp->worker_counts_map = fds[1];

  1113.             if (ngx_parse_addr_port(cycle->pool, &tmp, v, p - v) != NGX_OK) {
  1114.                 goto failed;
  1115.             }

  1117.             grp->sockaddr = ngx_pcalloc(cycle->pool, tmp.socklen);
  1118.             if (grp->sockaddr == NULL) {
  1119.                 goto failed;
  1120.             }

  1122.             ngx_memcpy(grp->sockaddr, tmp.sockaddr, tmp.socklen);
  1123.             grp->socklen = tmp.socklen;

  1125.             ngx_queue_insert_tail(&bcf->groups, &grp->queue);

  1127.             ngx_log_debug4(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  1128.                            "quic bpf sockmap inherited with "
  1129.                            "fds:%d/%d address:%*s",
  1130.                            fds[0], fds[1], p - v, v);

  1132.             nfd = 0;
  1133.             v = p + 1;
  1134.             break;

  1136.         default:
  1137.             break;
  1138.         }
  1139.     }

  1141.     return NGX_OK;

  1143. failed:

  1145.     for (i = 0; i < nfd; i++) {
  1146.         ngx_quic_bpf_close(cycle->log, fds[i], "inherited");
  1147.     }

  1149.     ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
  1150.                   "quic bpf failed to parse inherited QUIC BPF variable");

  1152.     return NGX_ERROR;
  1153. }


  1156. ngx_int_t
  1157. ‌ngx_quic_bpf_get_worker_fd(ngx_connection_t *lc, ngx_socket_t *fd)
  1158. {
  1159.     ngx_event_t               *rev;
  1160.     ngx_connection_t          *c;
  1161.     ngx_quic_bpf_conf_t       *bcf;
  1162.     ngx_quic_sock_group_t     *grp;
  1163.     ngx_quic_bpf_listening_t  *bpf_listening, *bls;

  1165.     bcf = ngx_quic_bpf_get_conf((ngx_cycle_t *) ngx_cycle);

  1167.     if (!bcf->enabled || !lc->listening->quic || !lc->listening->reuseport) {
  1168.         *fd = lc->fd;
  1169.         return NGX_OK;
  1170.     }

  1172.     grp = ngx_quic_bpf_find_group(bcf, lc->listening);

  1174.     if (grp == NULL) {
  1175.         *fd = lc->fd;
  1176.         return NGX_OK;
  1177.     }

  1179.     if (ngx_worker >= grp->listening.nelts) {
  1180.         return NGX_ERROR;
  1181.     }

  1183.     bpf_listening = grp->listening.elts;
  1184.     bls = &bpf_listening[ngx_worker];

  1186.     if (bls->fd == (ngx_socket_t) -1) {
  1187.         return NGX_ERROR;
  1188.     }

  1190.     if (bls->connection == NULL) {
  1191.         c = ngx_get_connection(bls->fd, lc->log);
  1192.         if (c == NULL) {
  1193.             return NGX_ERROR;
  1194.         }

  1196.         c->type = SOCK_DGRAM;
  1197.         c->log = lc->log;
  1198.         c->listening = bls->listening;

  1200.         rev = c->read;
  1201.         rev->quic = 1;
  1202.         rev->log = c->log;
  1203.         rev->handler = ngx_quic_recvmsg;

  1205.         if (ngx_add_event(rev, NGX_READ_EVENT, 0) == NGX_ERROR) {
  1206.             ngx_free_connection(c);
  1207.             return NGX_ERROR;
  1208.         }

  1210.         bls->connection = c;

  1212.         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, lc->log, 0,
  1213.                        "quic bpf socket connection fd:%d", bls->fd);
  1214.     }

  1216.     *fd = bls->fd;

  1218.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, lc->log, 0,
  1219.                    "quic bpf socket fd:%d", bls->fd);

  1221.     return NGX_OK;
  1222. }


  1225. ngx_int_t
  1226. ‌ngx_quic_bpf_get_worker_key(ngx_connection_t *c, uint64_t *key)
  1227. {
  1228.     ngx_quic_bpf_conf_t       *bcf;
  1229.     ngx_quic_sock_group_t     *grp;
  1230.     ngx_quic_bpf_listening_t  *bls;

  1232.     bcf = ngx_quic_bpf_get_conf((ngx_cycle_t *) ngx_cycle);

  1234.     if (!bcf->enabled || !c->listening->quic || !c->listening->reuseport) {
  1235.         return NGX_DECLINED;
  1236.     }

  1238.     grp = ngx_quic_bpf_find_group(bcf, c->listening);

  1240.     if (grp == NULL) {
  1241.         return NGX_DECLINED;
  1242.     }

  1244.     if (ngx_worker >= grp->listening.nelts) {
  1245.         return NGX_ERROR;
  1246.     }

  1248.     bls = grp->listening.elts;

  1250.     if (bls[ngx_worker].fd == (ngx_socket_t) -1) {
  1251.         return NGX_ERROR;
  1252.     }

  1254.     *key = bls[ngx_worker].key;

  1256.     return NGX_OK;
  1257. }

One Level Up Top Level