diff --git a/docs/config/network.en.md b/docs/config/network.en.md index 04854a7d..16b38854 100644 --- a/docs/config/network.en.md +++ b/docs/config/network.en.md @@ -12,6 +12,8 @@ between clients, OSDs and etcd. - [tcp_header_buffer_size](#tcp_header_buffer_size) - [use_sync_send_recv](#use_sync_send_recv) - [use_rdma](#use_rdma) +- [use_rdmacm](#use_rdmacm) +- [disable_tcp](#disable_tcp) - [rdma_device](#rdma_device) - [rdma_port_num](#rdma_port_num) - [rdma_gid_index](#rdma_gid_index) @@ -59,10 +61,33 @@ but may be required for clients with old kernel versions. - Type: boolean - Default: true -Try to use RDMA for communication if it's available. Disable if you don't -want Vitastor to use RDMA. TCP-only clients can also talk to an RDMA-enabled -cluster, so disabling RDMA may be needed if clients have RDMA devices, -but they are not connected to the cluster. +Try to use RDMA through libibverbs for communication if it's available. +Disable if you don't want Vitastor to use RDMA. TCP-only clients can also +talk to an RDMA-enabled cluster, so disabling RDMA may be needed if clients +have RDMA devices, but they are not connected to the cluster. + +`use_rdma` works with RoCEv1/RoCEv2 networks, but not with iWARP and, +maybe, with some Infiniband configurations which require RDMA-CM. +Consider `use_rdmacm` for such networks. + +## use_rdmacm + +- Type: boolean +- Default: true + +Use an alternative implementation of RDMA through RDMA-CM (Connection +Manager). Works with all RDMA networks: Infiniband, iWARP and +RoCEv1/RoCEv2, and even allows to disable TCP and run only with RDMA. +When enabled, OSDs listen on the same address(es) and port(s) using +TCP and RDMA-CM. `use_rdma` is automatically disabled when `use_rdmacm` +is enabled. + +## disable_tcp + +- Type: boolean +- Default: true + +Fully disable TCP and only use RDMA-CM for OSD communication. ## rdma_device @@ -93,12 +118,13 @@ PFC (Priority Flow Control) and ECN (Explicit Congestion Notification). ## rdma_port_num - Type: integer -- Default: 1 RDMA device port number to use. Only for devices that have more than 1 port. See `phys_port_cnt` in `ibv_devinfo -v` output to determine how many ports your device has. +Not relevant for RDMA-CM (use_rdmacm). + ## rdma_gid_index - Type: integer @@ -114,13 +140,14 @@ GID auto-selection is unsupported with libibverbs < v32. A correct rdma_gid_index for RoCEv2 is usually 1 (IPv6) or 3 (IPv4). +Not relevant for RDMA-CM (use_rdmacm). + ## rdma_mtu - Type: integer -- Default: 4096 -RDMA Path MTU to use. Must be 1024, 2048 or 4096. There is usually no -sense to change it from the default 4096. +RDMA Path MTU to use. Must be 1024, 2048 or 4096. Default is to use the +RDMA device's MTU. ## rdma_max_sge diff --git a/docs/config/network.ru.md b/docs/config/network.ru.md index b6575c98..96e66028 100644 --- a/docs/config/network.ru.md +++ b/docs/config/network.ru.md @@ -12,6 +12,8 @@ - [tcp_header_buffer_size](#tcp_header_buffer_size) - [use_sync_send_recv](#use_sync_send_recv) - [use_rdma](#use_rdma) +- [use_rdmacm](#use_rdmacm) +- [disable_tcp](#disable_tcp) - [rdma_device](#rdma_device) - [rdma_port_num](#rdma_port_num) - [rdma_gid_index](#rdma_gid_index) @@ -61,11 +63,34 @@ Vitastor содержат 128-байтные заголовки, за котор - Тип: булево (да/нет) - Значение по умолчанию: true -Пытаться использовать RDMA для связи при наличии доступных устройств. -Отключите, если вы не хотите, чтобы Vitastor использовал RDMA. -TCP-клиенты также могут работать с RDMA-кластером, так что отключать -RDMA может быть нужно только если у клиентов есть RDMA-устройства, -но они не имеют соединения с кластером Vitastor. +Попробовать использовать RDMA через libibverbs для связи при наличии +доступных устройств. Отключите, если вы не хотите, чтобы Vitastor +использовал RDMA. TCP-клиенты также могут работать с RDMA-кластером, +так что отключать RDMA может быть нужно, только если у клиентов есть +RDMA-устройства, но они не имеют соединения с кластером Vitastor. + +`use_rdma` работает с RoCEv1/RoCEv2 сетями, но не работает с iWARP и +может не работать с частью конфигураций Infiniband, требующих RDMA-CM. +Рассмотрите включение `use_rdmacm` для таких сетей. + +## use_rdmacm + +- Тип: булево (да/нет) +- Значение по умолчанию: true + +Использовать альтернативную реализацию RDMA на основе RDMA-CM (Connection +Manager). Работает со всеми типами RDMA-сетей: Infiniband, iWARP и +RoCEv1/RoCEv2, и даже позволяет полностью отключить TCP и работать +только на RDMA. Когда опция включена, OSD слушают один и тот же порт +на одних и тех же адресах через TCP и RDMA-CM. Также при включении +автоматически отключается опция `use_rdma`. + +## disable_tcp + +- Тип: булево (да/нет) +- Значение по умолчанию: true + +Полностью отключить TCP и использовать только RDMA-CM для соединений с OSD. ## rdma_device @@ -97,13 +122,14 @@ Control) и ECN (Explicit Congestion Notification). ## rdma_port_num - Тип: целое число -- Значение по умолчанию: 1 Номер порта RDMA-устройства, который следует использовать. Имеет смысл только для устройств, у которых более 1 порта. Чтобы узнать, сколько портов у вашего адаптера, посмотрите `phys_port_cnt` в выводе команды `ibv_devinfo -v`. +Опция неприменима к RDMA-CM (use_rdmacm). + ## rdma_gid_index - Тип: целое число @@ -120,13 +146,14 @@ libibverbs < v32. Правильный rdma_gid_index для RoCEv2, как правило, 1 (IPv6) или 3 (IPv4). +Опция неприменима к RDMA-CM (use_rdmacm). + ## rdma_mtu - Тип: целое число -- Значение по умолчанию: 4096 Максимальная единица передачи (Path MTU) для RDMA. Должно быть равно 1024, -2048 или 4096. Обычно нет смысла менять значение по умолчанию, равное 4096. +2048 или 4096. По умолчанию используется значение MTU RDMA-устройства. ## rdma_max_sge diff --git a/docs/config/src/network.yml b/docs/config/src/network.yml index fcfd58ce..e1a302d3 100644 --- a/docs/config/src/network.yml +++ b/docs/config/src/network.yml @@ -34,16 +34,48 @@ type: bool default: true info: | - Try to use RDMA for communication if it's available. Disable if you don't - want Vitastor to use RDMA. TCP-only clients can also talk to an RDMA-enabled - cluster, so disabling RDMA may be needed if clients have RDMA devices, - but they are not connected to the cluster. + Try to use RDMA through libibverbs for communication if it's available. + Disable if you don't want Vitastor to use RDMA. TCP-only clients can also + talk to an RDMA-enabled cluster, so disabling RDMA may be needed if clients + have RDMA devices, but they are not connected to the cluster. + + `use_rdma` works with RoCEv1/RoCEv2 networks, but not with iWARP and, + maybe, with some Infiniband configurations which require RDMA-CM. + Consider `use_rdmacm` for such networks. info_ru: | - Пытаться использовать RDMA для связи при наличии доступных устройств. - Отключите, если вы не хотите, чтобы Vitastor использовал RDMA. - TCP-клиенты также могут работать с RDMA-кластером, так что отключать - RDMA может быть нужно только если у клиентов есть RDMA-устройства, - но они не имеют соединения с кластером Vitastor. + Попробовать использовать RDMA через libibverbs для связи при наличии + доступных устройств. Отключите, если вы не хотите, чтобы Vitastor + использовал RDMA. TCP-клиенты также могут работать с RDMA-кластером, + так что отключать RDMA может быть нужно, только если у клиентов есть + RDMA-устройства, но они не имеют соединения с кластером Vitastor. + + `use_rdma` работает с RoCEv1/RoCEv2 сетями, но не работает с iWARP и + может не работать с частью конфигураций Infiniband, требующих RDMA-CM. + Рассмотрите включение `use_rdmacm` для таких сетей. +- name: use_rdmacm + type: bool + default: true + info: | + Use an alternative implementation of RDMA through RDMA-CM (Connection + Manager). Works with all RDMA networks: Infiniband, iWARP and + RoCEv1/RoCEv2, and even allows to disable TCP and run only with RDMA. + When enabled, OSDs listen on the same address(es) and port(s) using + TCP and RDMA-CM. `use_rdma` is automatically disabled when `use_rdmacm` + is enabled. + info_ru: | + Использовать альтернативную реализацию RDMA на основе RDMA-CM (Connection + Manager). Работает со всеми типами RDMA-сетей: Infiniband, iWARP и + RoCEv1/RoCEv2, и даже позволяет полностью отключить TCP и работать + только на RDMA. Когда опция включена, OSD слушают один и тот же порт + на одних и тех же адресах через TCP и RDMA-CM. Также при включении + автоматически отключается опция `use_rdma`. +- name: disable_tcp + type: bool + default: true + info: | + Fully disable TCP and only use RDMA-CM for OSD communication. + info_ru: | + Полностью отключить TCP и использовать только RDMA-CM для соединений с OSD. - name: rdma_device type: string info: | @@ -93,16 +125,19 @@ Control) и ECN (Explicit Congestion Notification). - name: rdma_port_num type: int - default: 1 info: | RDMA device port number to use. Only for devices that have more than 1 port. See `phys_port_cnt` in `ibv_devinfo -v` output to determine how many ports your device has. + + Not relevant for RDMA-CM (use_rdmacm). info_ru: | Номер порта RDMA-устройства, который следует использовать. Имеет смысл только для устройств, у которых более 1 порта. Чтобы узнать, сколько портов у вашего адаптера, посмотрите `phys_port_cnt` в выводе команды `ibv_devinfo -v`. + + Опция неприменима к RDMA-CM (use_rdmacm). - name: rdma_gid_index type: int info: | @@ -116,6 +151,8 @@ GID auto-selection is unsupported with libibverbs < v32. A correct rdma_gid_index for RoCEv2 is usually 1 (IPv6) or 3 (IPv4). + + Not relevant for RDMA-CM (use_rdmacm). info_ru: | Номер глобального идентификатора адреса RDMA-устройства, который следует использовать. Разным gid_index могут соответствовать разные протоколы связи: @@ -128,15 +165,16 @@ libibverbs < v32. Правильный rdma_gid_index для RoCEv2, как правило, 1 (IPv6) или 3 (IPv4). + + Опция неприменима к RDMA-CM (use_rdmacm). - name: rdma_mtu type: int - default: 4096 info: | - RDMA Path MTU to use. Must be 1024, 2048 or 4096. There is usually no - sense to change it from the default 4096. + RDMA Path MTU to use. Must be 1024, 2048 or 4096. Default is to use the + RDMA device's MTU. info_ru: | Максимальная единица передачи (Path MTU) для RDMA. Должно быть равно 1024, - 2048 или 4096. Обычно нет смысла менять значение по умолчанию, равное 4096. + 2048 или 4096. По умолчанию используется значение MTU RDMA-устройства. - name: rdma_max_sge type: int default: 128 diff --git a/docs/installation/source.en.md b/docs/installation/source.en.md index 6cb50537..da04f305 100644 --- a/docs/installation/source.en.md +++ b/docs/installation/source.en.md @@ -16,7 +16,7 @@ designated initializers support from C++20 - CMake - liburing, jerasure headers and libraries -- ISA-L, libibverbs headers and libraries (optional) +- ISA-L, libibverbs and librdmacm headers and libraries (optional) - tcmalloc (google-perftools-dev) ## Basic instructions diff --git a/docs/installation/source.ru.md b/docs/installation/source.ru.md index b9181d6d..3bc88e0e 100644 --- a/docs/installation/source.ru.md +++ b/docs/installation/source.ru.md @@ -16,7 +16,7 @@ назначенных инициализаторов (designated initializers) из C++20 - CMake - Заголовки и библиотеки liburing, jerasure -- Опционально - заголовки и библиотеки ISA-L, libibverbs +- Опционально - заголовки и библиотеки ISA-L, libibverbs, librdmacm - tcmalloc (google-perftools-dev) ## Базовая инструкция diff --git a/docs/intro/features.en.md b/docs/intro/features.en.md index 5b048997..d613c929 100644 --- a/docs/intro/features.en.md +++ b/docs/intro/features.en.md @@ -28,7 +28,7 @@ - Per-OSD and per-image I/O and space usage statistics in etcd - Snapshots and copy-on-write image clones - [Write throttling to smooth random write workloads in SSD+HDD configurations](../config/osd.en.md#throttle_small_writes) -- [RDMA/RoCEv2 support via libibverbs](../config/network.en.md#rdma_device) +- RDMA/RoCEv2 support [via libibverbs](../config/network.en.md#use_rdma) or [RDMA-CM](../config/network.en.md#use_rdmacm) - [Scrubbing](../config/osd.en.md#auto_scrub) (verification of copies) - [Checksums](../config/layout-osd.en.md#data_csum_type) - [Client write-back cache](../config/client.en.md#client_enable_writeback) diff --git a/docs/intro/features.ru.md b/docs/intro/features.ru.md index a2df8ad6..b58e33ac 100644 --- a/docs/intro/features.ru.md +++ b/docs/intro/features.ru.md @@ -30,7 +30,7 @@ - Именование инодов через хранение их метаданных в etcd - Снапшоты и copy-on-write клоны - [Сглаживание производительности случайной записи в SSD+HDD конфигурациях](../config/osd.ru.md#throttle_small_writes) -- [Поддержка RDMA/RoCEv2 через libibverbs](../config/network.ru.md#rdma_device) +- Поддержка RDMA/RoCEv2 [через libibverbs](../config/network.ru.md#use_rdma) или [RDMA-CM](../config/network.ru.md#use_rdmacm) - [Фоновая проверка целостности](../config/osd.ru.md#auto_scrub) (сверка копий) - [Контрольные суммы](../config/layout-osd.ru.md#data_csum_type) - [Буферизация записи на стороне клиента](../config/client.ru.md#client_enable_writeback) diff --git a/src/client/CMakeLists.txt b/src/client/CMakeLists.txt index bf99d0c1..29e65e7b 100644 --- a/src/client/CMakeLists.txt +++ b/src/client/CMakeLists.txt @@ -7,10 +7,14 @@ set(MSGR_RDMA "") if (IBVERBS_LIBRARIES) set(MSGR_RDMA "msgr_rdma.cpp") endif (IBVERBS_LIBRARIES) +set(MSGR_RDMACM "") +if (RDMACM_LIBRARIES) + set(MSGR_RDMACM "msgr_rdmacm.cpp") +endif (RDMACM_LIBRARIES) add_library(vitastor_common STATIC ../util/epoll_manager.cpp etcd_state_client.cpp messenger.cpp ../util/addr_util.cpp msgr_stop.cpp msgr_op.cpp msgr_send.cpp msgr_receive.cpp ../util/ringloop.cpp ../../json11/json11.cpp - http_client.cpp osd_ops.cpp pg_states.cpp ../util/timerfd_manager.cpp ../util/str_util.cpp ../util/json_util.cpp ${MSGR_RDMA} + http_client.cpp osd_ops.cpp pg_states.cpp ../util/timerfd_manager.cpp ../util/str_util.cpp ../util/json_util.cpp ${MSGR_RDMA} ${MSGR_RDMACM} ) target_link_libraries(vitastor_common pthread) target_compile_options(vitastor_common PUBLIC -fPIC) @@ -28,6 +32,7 @@ target_link_libraries(vitastor_client vitastor_cli ${LIBURING_LIBRARIES} ${IBVERBS_LIBRARIES} + ${RDMACM_LIBRARIES} ) set_target_properties(vitastor_client PROPERTIES VERSION ${VITASTOR_VERSION} SOVERSION 0) configure_file(vitastor.pc.in vitastor.pc @ONLY) diff --git a/src/client/messenger.cpp b/src/client/messenger.cpp index 6e9e4ae1..976bfad2 100644 --- a/src/client/messenger.cpp +++ b/src/client/messenger.cpp @@ -117,6 +117,28 @@ void msgr_iothread_t::run() void osd_messenger_t::init() { +#ifdef WITH_RDMACM + if (use_rdmacm) + { + // RDMA-CM only requires the event channel. All the remaining work is done separately + rdmacm_evch = rdma_create_event_channel(); + if (!rdmacm_evch) + { + // ENODEV means that the client doesn't have RDMA devices available + if (errno != ENODEV || log_level > 0) + fprintf(stderr, "Failed to initialize RDMA-CM event channel: %s (code %d)\n", strerror(errno), errno); + } + else + { + fcntl(rdmacm_evch->fd, F_SETFL, fcntl(rdmacm_evch->fd, F_GETFL, 0) | O_NONBLOCK); + tfd->set_fd_handler(rdmacm_evch->fd, false, [this](int rdmacm_eventfd, int epoll_events) + { + handle_rdmacm_events(); + }); + } + } + else +#endif #ifdef WITH_RDMA if (use_rdma) { @@ -255,6 +277,14 @@ osd_messenger_t::~osd_messenger_t() } rdma_contexts.clear(); #endif +#ifdef WITH_RDMACM + if (rdmacm_evch) + { + tfd->set_fd_handler(rdmacm_evch->fd, false, NULL); + rdma_destroy_event_channel(rdmacm_evch); + rdmacm_evch = NULL; + } +#endif } void osd_messenger_t::parse_config(const json11::Json & config) @@ -265,6 +295,12 @@ void osd_messenger_t::parse_config(const json11::Json & config) // RDMA is on by default in RDMA-enabled builds this->use_rdma = config["use_rdma"].bool_value() || config["use_rdma"].uint64_value() != 0; } +#ifdef WITH_RDMACM + // Use RDMA CM? (required for iWARP and may be useful for IB) + // FIXME: Only parse during start + this->use_rdmacm = config["use_rdmacm"].bool_value() || config["use_rdmacm"].uint64_value() != 0; + this->disable_tcp = this->use_rdmacm && (config["disable_tcp"].bool_value() || config["disable_tcp"].uint64_value() != 0); +#endif this->rdma_device = config["rdma_device"].string_value(); this->rdma_port_num = (uint8_t)config["rdma_port_num"].uint64_value(); if (!config["rdma_gid_index"].is_null()) @@ -383,6 +419,9 @@ void osd_messenger_t::connect_peer(uint64_t peer_osd, json11::Json peer_state) wanted_peers[peer_osd].address_list = peer_state["addresses"]; wanted_peers[peer_osd].address_changed = true; } +#ifdef WITH_RDMACM + wanted_peers[peer_osd].peer_rdmacm = peer_state["rdmacm"].bool_value(); +#endif wanted_peers[peer_osd].port = (int)peer_state["port"].int64_value(); try_connect_peer(peer_osd); } @@ -408,12 +447,24 @@ void osd_messenger_t::try_connect_peer(uint64_t peer_osd) wp.cur_addr = wp.address_list[wp.address_index].string_value(); wp.cur_port = wp.port; wp.connecting = true; - try_connect_peer_addr(peer_osd, wp.cur_addr.c_str(), wp.cur_port); +#ifdef WITH_RDMACM + if (use_rdmacm && wp.peer_rdmacm) + rdmacm_try_connect_peer(peer_osd, wp.cur_addr.c_str(), wp.cur_port); + else +#endif + try_connect_peer_tcp(peer_osd, wp.cur_addr.c_str(), wp.cur_port); } -void osd_messenger_t::try_connect_peer_addr(osd_num_t peer_osd, const char *peer_host, int peer_port) +void osd_messenger_t::try_connect_peer_tcp(osd_num_t peer_osd, const char *peer_host, int peer_port) { assert(peer_osd != this->osd_num); +#ifdef WITH_RDMACM + if (disable_tcp) + { + on_connect_peer(peer_osd, -EINVAL); + return; + } +#endif struct sockaddr_storage addr; if (!string_to_addr(peer_host, 0, peer_port, &addr)) { @@ -749,6 +800,11 @@ bool osd_messenger_t::is_rdma_enabled() { return rdma_contexts.size() > 0; } + +bool osd_messenger_t::is_use_rdmacm() +{ + return use_rdmacm; +} #endif json11::Json::object osd_messenger_t::read_config(const json11::Json & config) diff --git a/src/client/messenger.h b/src/client/messenger.h index 23e28f29..55a803f8 100644 --- a/src/client/messenger.h +++ b/src/client/messenger.h @@ -50,10 +50,10 @@ struct osd_client_t { int refs = 0; - sockaddr_storage peer_addr; - int peer_port; + sockaddr_storage peer_addr = {}; + int peer_port = 0; int peer_fd = -1; - int peer_state; + int peer_state = 0; int connect_timeout_id = -1; int ping_time_remaining = 0; int idle_time_remaining = 0; @@ -96,6 +96,7 @@ struct osd_wanted_peer_t { json11::Json raw_address_list; json11::Json address_list; + bool peer_rdmacm = false; int port = 0; time_t last_connect_attempt = 0; bool connecting = false, address_changed = false; @@ -151,6 +152,15 @@ public: }; #endif +#ifdef WITH_RDMA +struct rdma_event_channel; +struct rdma_cm_id; +struct rdma_cm_event; +struct ibv_context; +struct osd_messenger_t; +struct rdmacm_connecting_t; +#endif + struct osd_messenger_t { protected: @@ -167,6 +177,8 @@ protected: #ifdef WITH_RDMA bool use_rdma = true; + bool use_rdmacm = false; + bool disable_tcp = false; std::string rdma_device; uint64_t rdma_port_num = 1; int rdma_mtu = 0; @@ -175,6 +187,9 @@ protected: uint64_t rdma_max_sge = 0, rdma_max_send = 0, rdma_max_recv = 0; uint64_t rdma_max_msg = 0; bool rdma_odp = false; + rdma_event_channel *rdmacm_evch = NULL; + std::map rdmacm_connections; + std::map rdmacm_connecting; #endif std::vector iothreads; @@ -224,13 +239,18 @@ public: bool is_rdma_enabled(); bool connect_rdma(int peer_fd, std::string rdma_address, uint64_t client_max_msg); #endif +#ifdef WITH_RDMACM + bool is_use_rdmacm(); + rdma_cm_id *rdmacm_listen(const std::string & bind_address, int rdmacm_port, int *bound_port, int log_level); + void rdmacm_destroy_listener(rdma_cm_id *listener); +#endif void inc_op_stats(osd_op_stats_t & stats, uint64_t opcode, timespec & tv_begin, timespec & tv_end, uint64_t len); void measure_exec(osd_op_t *cur_op); protected: void try_connect_peer(uint64_t osd_num); - void try_connect_peer_addr(osd_num_t peer_osd, const char *peer_host, int peer_port); + void try_connect_peer_tcp(osd_num_t peer_osd, const char *peer_host, int peer_port); void handle_peer_epoll(int peer_fd, int epoll_events); void handle_connect_epoll(int peer_fd); void on_connect_peer(osd_num_t peer_osd, int peer_fd); @@ -258,4 +278,15 @@ protected: void handle_rdma_events(msgr_rdma_context_t *rdma_context); msgr_rdma_context_t* choose_rdma_context(osd_client_t *cl); #endif +#ifdef WITH_RDMACM + void handle_rdmacm_events(); + msgr_rdma_context_t* rdmacm_get_context(ibv_context *verbs); + msgr_rdma_context_t* rdmacm_create_qp(rdma_cm_id *cmid); + void rdmacm_accept(rdma_cm_event *ev); + void rdmacm_try_connect_peer(uint64_t peer_osd, const std::string & addr, int peer_port); + void rdmacm_on_connect_peer_error(rdma_cm_id *cmid, int res); + void rdmacm_address_resolved(rdma_cm_event *ev); + void rdmacm_route_resolved(rdma_cm_event *ev); + void rdmacm_established(rdma_cm_event *ev); +#endif }; diff --git a/src/client/msgr_rdma.cpp b/src/client/msgr_rdma.cpp index fbdfb444..7c473ba7 100644 --- a/src/client/msgr_rdma.cpp +++ b/src/client/msgr_rdma.cpp @@ -63,15 +63,22 @@ msgr_rdma_context_t::~msgr_rdma_context_t() ibv_dereg_mr(mr); if (pd) ibv_dealloc_pd(pd); - if (context) + if (context && !is_cm) ibv_close_device(context); } msgr_rdma_connection_t::~msgr_rdma_connection_t() { - ctx->used_max_cqe -= max_send+max_recv; - if (qp) + ctx->reserve_cqe(-max_send-max_recv); + if (qp && !cmid) ibv_destroy_qp(qp); + if (cmid) + { + ctx->cm_refs--; + if (cmid->qp) + rdma_destroy_qp(cmid); + rdma_destroy_id(cmid); + } if (recv_buffers.size()) { for (auto b: recv_buffers) @@ -388,9 +395,34 @@ cleanup: return NULL; } +bool msgr_rdma_context_t::reserve_cqe(int n) +{ + this->used_max_cqe += n; + if (this->used_max_cqe > this->max_cqe) + { + // Resize CQ + // Mellanox ConnectX-4 supports up to 4194303 CQEs, so it's fine to put everything into a single CQ + int new_max_cqe = this->max_cqe; + while (this->used_max_cqe > new_max_cqe) + { + new_max_cqe *= 2; + } + if (ibv_resize_cq(this->cq, new_max_cqe) != 0) + { + fprintf(stderr, "Couldn't resize RDMA completion queue to %d entries\n", new_max_cqe); + return false; + } + this->max_cqe = new_max_cqe; + } + return true; +} + msgr_rdma_connection_t *msgr_rdma_connection_t::create(msgr_rdma_context_t *ctx, uint32_t max_send, uint32_t max_recv, uint32_t max_sge, uint32_t max_msg) { + if (!ctx->reserve_cqe(max_send+max_recv)) + return NULL; + msgr_rdma_connection_t *conn = new msgr_rdma_connection_t; max_sge = max_sge > ctx->attrx.orig_attr.max_sge ? ctx->attrx.orig_attr.max_sge : max_sge; @@ -401,25 +433,6 @@ msgr_rdma_connection_t *msgr_rdma_connection_t::create(msgr_rdma_context_t *ctx, conn->max_sge = max_sge; conn->max_msg = max_msg; - ctx->used_max_cqe += max_send+max_recv; - if (ctx->used_max_cqe > ctx->max_cqe) - { - // Resize CQ - // Mellanox ConnectX-4 supports up to 4194303 CQEs, so it's fine to put everything into a single CQ - int new_max_cqe = ctx->max_cqe; - while (ctx->used_max_cqe > new_max_cqe) - { - new_max_cqe *= 2; - } - if (ibv_resize_cq(ctx->cq, new_max_cqe) != 0) - { - fprintf(stderr, "Couldn't resize RDMA completion queue to %d entries\n", new_max_cqe); - delete conn; - return NULL; - } - ctx->max_cqe = new_max_cqe; - } - ibv_qp_init_attr init_attr = { .send_cq = ctx->cq, .recv_cq = ctx->cq, diff --git a/src/client/msgr_rdma.h b/src/client/msgr_rdma.h index 32caec01..daf905ae 100644 --- a/src/client/msgr_rdma.h +++ b/src/client/msgr_rdma.h @@ -2,6 +2,9 @@ // License: VNPL-1.1 or GNU GPL-2.0+ (see README.md for details) #pragma once +#ifdef WITH_RDMACM +#include +#endif #include #include #include @@ -36,11 +39,15 @@ struct msgr_rdma_context_t int max_cqe = 0; int used_max_cqe = 0; addr_mask_t net_mask = {}; + bool is_cm = false; + int cm_refs = 0; static std::vector create_all(const std::vector & osd_network_masks, const char *sel_dev_name, int sel_port_num, int sel_gid_index, uint32_t sel_mtu, bool odp, int log_level); static msgr_rdma_context_t *create(ibv_device *dev, ibv_port_attr & portinfo, int ib_port, int gid_index, uint32_t mtu, bool odp, int log_level); + static msgr_rdma_context_t* create_cm(ibv_context *ctx); + bool reserve_cqe(int n); ~msgr_rdma_context_t(); }; @@ -55,11 +62,14 @@ struct msgr_rdma_connection_t { msgr_rdma_context_t *ctx = NULL; ibv_qp *qp = NULL; +#ifdef WITH_RDMACM + rdma_cm_id *cmid = NULL; +#endif msgr_rdma_address_t addr; int max_send = 0, max_recv = 0, max_sge = 0; - int cur_send = 0, cur_recv = 0; uint64_t max_msg = 0; + int cur_send = 0, cur_recv = 0; int send_pos = 0, send_buf_pos = 0; int next_recv_buf = 0; std::vector recv_buffers; diff --git a/src/client/msgr_rdmacm.cpp b/src/client/msgr_rdmacm.cpp new file mode 100644 index 00000000..0e61e710 --- /dev/null +++ b/src/client/msgr_rdmacm.cpp @@ -0,0 +1,525 @@ +// Copyright (c) Vitaliy Filippov, 2019+ +// License: VNPL-1.1 or GNU GPL-2.0+ (see README.md for details) + +#include +#include +#include +#include +#include "msgr_rdma.h" +#include "messenger.h" + +struct rdmacm_connecting_t +{ + rdma_cm_id *cmid = NULL; + int peer_fd = -1; + osd_num_t peer_osd = 0; + std::string addr; + sockaddr_storage parsed_addr = {}; + int peer_port = 0; + int timeout_ms = 0; + int timeout_id = -1; + msgr_rdma_context_t *rdma_context = NULL; +}; + +rdma_cm_id *osd_messenger_t::rdmacm_listen(const std::string & bind_address, int rdmacm_port, int *bound_port, int log_level) +{ + sockaddr_storage addr = {}; + rdma_cm_id *listener = NULL; + int r = rdma_create_id(rdmacm_evch, &listener, NULL, RDMA_PS_TCP); + if (r != 0) + { + fprintf(stderr, "Failed to create RDMA-CM ID: %s (code %d)\n", strerror(errno), errno); + goto fail; + } + if (!string_to_addr(bind_address, 0, rdmacm_port, &addr)) + { + fprintf(stderr, "Server address: %s is not valid\n", bind_address.c_str()); + goto fail; + } + r = rdma_bind_addr(listener, (sockaddr*)&addr); + if (r != 0) + { + fprintf(stderr, "Failed to bind RDMA-CM to %s:%d: %s (code %d)\n", bind_address.c_str(), rdmacm_port, strerror(errno), errno); + goto fail; + } + r = rdma_listen(listener, 128); + if (r != 0) + { + fprintf(stderr, "Failed to listen to RDMA-CM address %s:%d: %s (code %d)\n", bind_address.c_str(), rdmacm_port, strerror(errno), errno); + goto fail; + } + if (bound_port) + { + *bound_port = ntohs(rdma_get_src_port(listener)); + } + if (log_level > 0) + { + fprintf(stderr, "Listening to RDMA-CM address %s port %d\n", bind_address.c_str(), *bound_port); + } + return listener; +fail: + rdma_destroy_id(listener); + return NULL; +} + +void osd_messenger_t::rdmacm_destroy_listener(rdma_cm_id *listener) +{ + rdma_destroy_id(listener); +} + +void osd_messenger_t::handle_rdmacm_events() +{ + // rdma_destroy_id infinitely waits for pthread_cond if called before all events are acked :-( + std::vector events_copy; + while (1) + { + rdma_cm_event *ev = NULL; + int r = rdma_get_cm_event(rdmacm_evch, &ev); + if (r != 0) + { + if (errno == EAGAIN || errno == EINTR) + break; + fprintf(stderr, "Failed to get RDMA-CM event: %s (code %d)\n", strerror(errno), errno); + exit(1); + } + events_copy.push_back(*ev); + r = rdma_ack_cm_event(ev); + if (r != 0) + { + fprintf(stderr, "Failed to ack (free) RDMA-CM event: %s (code %d)\n", strerror(errno), errno); + exit(1); + } + } + for (auto & evl: events_copy) + { + auto ev = &evl; + if (ev->event == RDMA_CM_EVENT_CONNECT_REQUEST) + { + rdmacm_accept(ev); + } + else if (ev->event == RDMA_CM_EVENT_CONNECT_ERROR || + ev->event == RDMA_CM_EVENT_REJECTED || + ev->event == RDMA_CM_EVENT_DISCONNECTED || + ev->event == RDMA_CM_EVENT_DEVICE_REMOVAL) + { + auto event_type_name = ev->event == RDMA_CM_EVENT_CONNECT_ERROR ? "RDMA_CM_EVENT_CONNECT_ERROR" : ( + ev->event == RDMA_CM_EVENT_REJECTED ? "RDMA_CM_EVENT_REJECTED" : ( + ev->event == RDMA_CM_EVENT_DISCONNECTED ? "RDMA_CM_EVENT_DISCONNECTED" : "RDMA_CM_EVENT_DEVICE_REMOVAL")); + auto cli_it = rdmacm_connections.find(ev->id); + if (cli_it != rdmacm_connections.end()) + { + fprintf(stderr, "Received %s event for peer %d, closing connection\n", + event_type_name, cli_it->second->peer_fd); + stop_client(cli_it->second->peer_fd); + } + else if (rdmacm_connecting.find(ev->id) != rdmacm_connecting.end()) + { + fprintf(stderr, "Received %s event for RDMA-CM OSD %ju connection\n", + event_type_name, rdmacm_connecting[ev->id]->peer_osd); + rdmacm_established(ev); + } + else + { + fprintf(stderr, "Received %s event for an unknown RDMA-CM connection 0x%jx - ignoring\n", + event_type_name, (uint64_t)ev->id); + } + } + else if (ev->event == RDMA_CM_EVENT_ADDR_RESOLVED || ev->event == RDMA_CM_EVENT_ADDR_ERROR) + { + rdmacm_address_resolved(ev); + } + else if (ev->event == RDMA_CM_EVENT_ROUTE_RESOLVED || ev->event == RDMA_CM_EVENT_ROUTE_ERROR) + { + rdmacm_route_resolved(ev); + } + else if (ev->event == RDMA_CM_EVENT_CONNECT_RESPONSE) + { + // Just OK + } + else if (ev->event == RDMA_CM_EVENT_UNREACHABLE || ev->event == RDMA_CM_EVENT_REJECTED) + { + // Handle error + rdmacm_established(ev); + } + else if (ev->event == RDMA_CM_EVENT_ESTABLISHED) + { + rdmacm_established(ev); + } + else if (ev->event == RDMA_CM_EVENT_ADDR_CHANGE || ev->event == RDMA_CM_EVENT_TIMEWAIT_EXIT) + { + // Do nothing + } + else + { + // Other events are unexpected + fprintf(stderr, "Unexpected RDMA-CM event type: %d\n", ev->event); + } + } +} + +msgr_rdma_context_t* msgr_rdma_context_t::create_cm(ibv_context *ctx) +{ + auto rdma_context = new msgr_rdma_context_t; + rdma_context->is_cm = true; + rdma_context->context = ctx; + rdma_context->pd = ibv_alloc_pd(ctx); + if (!rdma_context->pd) + { + fprintf(stderr, "Couldn't allocate RDMA protection domain\n"); + delete rdma_context; + return NULL; + } + rdma_context->odp = false; + rdma_context->channel = ibv_create_comp_channel(rdma_context->context); + if (!rdma_context->channel) + { + fprintf(stderr, "Couldn't create RDMA completion channel\n"); + delete rdma_context; + return NULL; + } + rdma_context->max_cqe = 4096; + rdma_context->cq = ibv_create_cq(rdma_context->context, rdma_context->max_cqe, NULL, rdma_context->channel, 0); + if (!rdma_context->cq) + { + fprintf(stderr, "Couldn't create RDMA completion queue\n"); + delete rdma_context; + return NULL; + } + if (ibv_query_device_ex(rdma_context->context, NULL, &rdma_context->attrx)) + { + fprintf(stderr, "Couldn't query RDMA device for its features\n"); + delete rdma_context; + return NULL; + } + return rdma_context; +} + +msgr_rdma_context_t* osd_messenger_t::rdmacm_get_context(ibv_context *verbs) +{ + // Find the context by device + // We assume that RDMA_CM ev->id->verbs is always the same for the same device (but PD for example isn't) + msgr_rdma_context_t *rdma_context = NULL; + for (auto ctx: rdma_contexts) + { + if (ctx->context == verbs) + { + rdma_context = ctx; + break; + } + } + if (!rdma_context) + { + // Wrap into a new msgr_rdma_context_t + rdma_context = msgr_rdma_context_t::create_cm(verbs); + if (!rdma_context) + return NULL; + fcntl(rdma_context->channel->fd, F_SETFL, fcntl(rdma_context->channel->fd, F_GETFL, 0) | O_NONBLOCK); + tfd->set_fd_handler(rdma_context->channel->fd, false, [this, rdma_context](int notify_fd, int epoll_events) + { + handle_rdma_events(rdma_context); + }); + handle_rdma_events(rdma_context); + rdma_contexts.push_back(rdma_context); + } + return rdma_context; +} + +msgr_rdma_context_t* osd_messenger_t::rdmacm_create_qp(rdma_cm_id *cmid) +{ + auto rdma_context = rdmacm_get_context(cmid->verbs); + if (!rdma_context) + { + return NULL; + } + rdma_context->reserve_cqe(rdma_max_send+rdma_max_recv); + auto max_sge = rdma_max_sge > rdma_context->attrx.orig_attr.max_sge + ? rdma_context->attrx.orig_attr.max_sge : rdma_max_sge; + ibv_qp_init_attr init_attr = { + .send_cq = rdma_context->cq, + .recv_cq = rdma_context->cq, + .cap = { + .max_send_wr = (uint32_t)rdma_max_send, + .max_recv_wr = (uint32_t)rdma_max_recv, + .max_send_sge = (uint32_t)max_sge, + .max_recv_sge = (uint32_t)max_sge, + }, + .qp_type = IBV_QPT_RC, + }; + int r = rdma_create_qp(cmid, rdma_context->pd, &init_attr); + if (r != 0) + { + fprintf(stderr, "Failed to create a queue pair via RDMA-CM: %s (code %d)\n", strerror(errno), errno); + rdma_context->reserve_cqe(-rdma_max_send-rdma_max_recv); + return NULL; + } + return rdma_context; +} + +void osd_messenger_t::rdmacm_accept(rdma_cm_event *ev) +{ + // Make a fake FD (FIXME: do not use FDs for identifying clients!) + int fake_fd = socket(AF_INET, SOCK_STREAM, 0); + if (fake_fd < 0) + { + fprintf(stderr, "Failed to allocate a fake socket for RDMA-CM client: %s (code %d)\n", strerror(errno), errno); + rdma_destroy_id(ev->id); + return; + } + auto rdma_context = rdmacm_create_qp(ev->id); + if (!rdma_context) + { + rdma_destroy_id(ev->id); + return; + } + // We don't need private_data, RDMA_READ or ATOMIC so use default 1 + rdma_conn_param conn_params = { + .responder_resources = 1, + .initiator_depth = 1, + .retry_count = 7, + .rnr_retry_count = 7, + }; + if (rdma_accept(ev->id, &conn_params) != 0) + { + fprintf(stderr, "Failed to accept RDMA-CM connection: %s (code %d)\n", strerror(errno), errno); + rdma_context->reserve_cqe(-rdma_max_send-rdma_max_recv); + rdma_destroy_qp(ev->id); + rdma_destroy_id(ev->id); + return; + } + rdma_context->cm_refs++; + // Wrap into a new msgr_rdma_connection_t + msgr_rdma_connection_t *conn = new msgr_rdma_connection_t; + conn->ctx = rdma_context; + conn->max_send = rdma_max_send; + conn->max_recv = rdma_max_recv; + conn->max_sge = rdma_max_sge > rdma_context->attrx.orig_attr.max_sge + ? rdma_context->attrx.orig_attr.max_sge : rdma_max_sge; + conn->max_msg = rdma_max_msg; + conn->cmid = ev->id; + conn->qp = ev->id->qp; + auto cl = new osd_client_t(); + cl->peer_fd = fake_fd; + cl->peer_state = PEER_RDMA; + cl->peer_addr = *(sockaddr_storage*)rdma_get_peer_addr(ev->id); + cl->in_buf = malloc_or_die(receive_buffer_size); + cl->rdma_conn = conn; + clients[fake_fd] = cl; + rdmacm_connections[ev->id] = cl; + // Add initial receive request(s) + try_recv_rdma(cl); + fprintf(stderr, "[OSD %ju] new client %d: connection from %s via RDMA-CM\n", this->osd_num, fake_fd, + addr_to_string(cl->peer_addr).c_str()); +} + +void osd_messenger_t::rdmacm_on_connect_peer_error(rdma_cm_id *cmid, int res) +{ + auto conn = rdmacm_connecting.at(cmid); + auto addr = conn->addr; + auto peer_port = conn->peer_port; + auto peer_osd = conn->peer_osd; + if (conn->timeout_id >= 0) + tfd->clear_timer(conn->timeout_id); + if (conn->peer_fd >= 0) + close(conn->peer_fd); + if (conn->rdma_context) + conn->rdma_context->reserve_cqe(-rdma_max_send-rdma_max_recv); + if (conn->cmid) + { + if (conn->cmid->qp) + rdma_destroy_qp(conn->cmid); + rdma_destroy_id(conn->cmid); + } + rdmacm_connecting.erase(cmid); + delete conn; + if (!disable_tcp) + { + // Fall back to TCP instead of just reporting the error to on_connect_peer() + try_connect_peer_tcp(peer_osd, addr.c_str(), peer_port); + } + else + { + // TCP is disabled + on_connect_peer(peer_osd, res == 0 ? -EINVAL : (res > 0 ? -res : res)); + } +} + +void osd_messenger_t::rdmacm_try_connect_peer(uint64_t peer_osd, const std::string & addr, int peer_port) +{ + struct sockaddr_storage sa = {}; + if (!string_to_addr(addr, false, peer_port, &sa)) + { + fprintf(stderr, "Address %s is invalid\n", addr.c_str()); + on_connect_peer(peer_osd, -EINVAL); + return; + } + rdma_cm_id *cmid = NULL; + if (rdma_create_id(rdmacm_evch, &cmid, NULL, RDMA_PS_TCP) != 0) + { + int res = -errno; + fprintf(stderr, "Failed to create RDMA-CM ID: %s (code %d), using TCP\n", strerror(errno), errno); + if (!disable_tcp) + try_connect_peer_tcp(peer_osd, addr.c_str(), peer_port); + else + on_connect_peer(peer_osd, res); + return; + } + // Make a fake FD (FIXME: do not use FDs for identifying clients!) + int fake_fd = socket(AF_INET, SOCK_STREAM, 0); + if (fake_fd < 0) + { + int res = -errno; + rdma_destroy_id(cmid); + // Can't create socket, pointless to try TCP + on_connect_peer(peer_osd, res); + return; + } + auto conn = new rdmacm_connecting_t; + rdmacm_connecting[cmid] = conn; + conn->cmid = cmid; + conn->peer_fd = fake_fd; + conn->peer_osd = peer_osd; + conn->addr = addr; + conn->parsed_addr = sa; + conn->peer_port = peer_port; + conn->timeout_ms = peer_connect_timeout*1000; + conn->timeout_id = -1; + if (peer_connect_timeout > 0) + { + conn->timeout_id = tfd->set_timer(1000*peer_connect_timeout, false, [this, cmid](int timer_id) + { + auto conn = rdmacm_connecting.at(cmid); + conn->timeout_id = -1; + fprintf(stderr, "RDMA-CM connection to %s timed out\n", conn->addr.c_str()); + rdmacm_on_connect_peer_error(cmid, -EPIPE); + return; + }); + } + if (rdma_resolve_addr(cmid, NULL, (sockaddr*)&conn->parsed_addr, conn->timeout_ms) != 0) + { + auto res = -errno; + // ENODEV means that the client doesn't have an RDMA device for this address + if (res != -ENODEV || log_level > 0) + fprintf(stderr, "Failed to resolve address %s via RDMA-CM: %s (code %d)\n", addr.c_str(), strerror(errno), errno); + rdmacm_on_connect_peer_error(cmid, res); + return; + } +} + +void osd_messenger_t::rdmacm_address_resolved(rdma_cm_event *ev) +{ + auto cmid = ev->id; + auto conn_it = rdmacm_connecting.find(cmid); + if (conn_it == rdmacm_connecting.end()) + { + // Silently ignore unknown IDs + return; + } + auto conn = conn_it->second; + if (ev->event != RDMA_CM_EVENT_ADDR_RESOLVED || ev->status != 0) + { + fprintf(stderr, "Failed to resolve address %s via RDMA-CM: %s (code %d)\n", conn->addr.c_str(), + ev->status > 0 ? "unknown error" : strerror(-ev->status), ev->status); + rdmacm_on_connect_peer_error(cmid, ev->status); + return; + } + auto rdma_context = rdmacm_create_qp(cmid); + if (!rdma_context) + { + rdmacm_on_connect_peer_error(cmid, -EIO); + return; + } + conn->rdma_context = rdma_context; + if (rdma_resolve_route(cmid, conn->timeout_ms) != 0) + { + int res = -errno; + fprintf(stderr, "Failed to resolve route to %s via RDMA-CM: %s (code %d)\n", conn->addr.c_str(), strerror(errno), errno); + rdmacm_on_connect_peer_error(cmid, res); + return; + } +} + +void osd_messenger_t::rdmacm_route_resolved(rdma_cm_event *ev) +{ + auto cmid = ev->id; + auto conn_it = rdmacm_connecting.find(cmid); + if (conn_it == rdmacm_connecting.end()) + { + // Silently ignore unknown IDs + return; + } + auto conn = conn_it->second; + if (ev->event != RDMA_CM_EVENT_ROUTE_RESOLVED || ev->status != 0) + { + fprintf(stderr, "Failed to resolve route to %s via RDMA-CM: %s (code %d)\n", conn->addr.c_str(), + ev->status > 0 ? "unknown error" : strerror(-ev->status), ev->status); + rdmacm_on_connect_peer_error(cmid, ev->status); + return; + } + // We don't need private_data, RDMA_READ or ATOMIC so use default 1 + rdma_conn_param conn_params = { + .responder_resources = 1, + .initiator_depth = 1, + .retry_count = 7, + .rnr_retry_count = 7, + }; + if (rdma_connect(cmid, &conn_params) != 0) + { + int res = -errno; + fprintf(stderr, "Failed to connect to %s:%d via RDMA-CM: %s (code %d)\n", conn->addr.c_str(), conn->peer_port, strerror(errno), errno); + rdmacm_on_connect_peer_error(cmid, res); + return; + } +} + +void osd_messenger_t::rdmacm_established(rdma_cm_event *ev) +{ + auto cmid = ev->id; + auto conn_it = rdmacm_connecting.find(cmid); + if (conn_it == rdmacm_connecting.end()) + { + // Silently ignore unknown IDs + return; + } + auto conn = conn_it->second; + auto peer_osd = conn->peer_osd; + if (ev->event != RDMA_CM_EVENT_ESTABLISHED || ev->status != 0) + { + fprintf(stderr, "Failed to connect to %s:%d via RDMA-CM: %s (code %d)\n", conn->addr.c_str(), conn->peer_port, + ev->status > 0 ? "unknown error" : strerror(-ev->status), ev->status); + rdmacm_on_connect_peer_error(cmid, ev->status); + return; + } + // Wrap into a new msgr_rdma_connection_t + msgr_rdma_connection_t *rc = new msgr_rdma_connection_t; + rc->ctx = conn->rdma_context; + rc->ctx->cm_refs++; + rc->max_send = rdma_max_send; + rc->max_recv = rdma_max_recv; + rc->max_sge = rdma_max_sge > rc->ctx->attrx.orig_attr.max_sge + ? rc->ctx->attrx.orig_attr.max_sge : rdma_max_sge; + rc->max_msg = rdma_max_msg; + rc->cmid = conn->cmid; + rc->qp = conn->cmid->qp; + // And an osd_client_t + auto cl = new osd_client_t(); + cl->peer_addr = conn->parsed_addr; + cl->peer_port = conn->peer_port; + cl->peer_fd = conn->peer_fd; + cl->peer_state = PEER_RDMA; + cl->connect_timeout_id = -1; + cl->osd_num = peer_osd; + cl->in_buf = malloc_or_die(receive_buffer_size); + cl->rdma_conn = rc; + clients[conn->peer_fd] = cl; + if (conn->timeout_id >= 0) + tfd->clear_timer(conn->timeout_id); + delete conn; + rdmacm_connecting.erase(cmid); + rdmacm_connections[cmid] = cl; + if (log_level > 0) + fprintf(stderr, "Successfully connected with OSD %ju using RDMA-CM\n", peer_osd); + // Add initial receive request(s) + try_recv_rdma(cl); + osd_peer_fds[peer_osd] = cl->peer_fd; + on_connect_peer(peer_osd, cl->peer_fd); +} diff --git a/src/osd/CMakeLists.txt b/src/osd/CMakeLists.txt index a41fd9c1..cf37b9a8 100644 --- a/src/osd/CMakeLists.txt +++ b/src/osd/CMakeLists.txt @@ -14,6 +14,7 @@ target_link_libraries(vitastor-osd Jerasure ${ISAL_LIBRARIES} ${IBVERBS_LIBRARIES} + ${RDMACM_LIBRARIES} ) # osd_rmw_test diff --git a/src/osd/osd.cpp b/src/osd/osd.cpp index 6a884d3b..6726543f 100644 --- a/src/osd/osd.cpp +++ b/src/osd/osd.cpp @@ -120,6 +120,11 @@ osd_t::~osd_t() delete epmgr; if (bs) delete bs; +#ifdef WITH_RDMACM + for (rdma_cm_id *listener: rdmacm_listeners) + msgr.rdmacm_destroy_listener(listener); + rdmacm_listeners.clear(); +#endif for (auto listen_fd: listen_fds) close(listen_fd); listen_fds.clear(); @@ -176,6 +181,11 @@ void osd_t::parse_config(bool init) bind_port = config["bind_port"].uint64_value(); if (bind_port <= 0 || bind_port > 65535) bind_port = 0; +#ifdef WITH_RDMACM + // Use RDMA CM? (required for iWARP and may be useful for IB) + this->use_rdmacm = config["use_rdmacm"].bool_value() || config["use_rdmacm"].uint64_value() != 0; + this->disable_tcp = this->use_rdmacm && (config["disable_tcp"].bool_value() || config["disable_tcp"].uint64_value() != 0); +#endif // OSD configuration etcd_report_interval = config["etcd_report_interval"].uint64_value(); if (etcd_report_interval <= 0) @@ -348,16 +358,35 @@ void osd_t::bind_socket() { bind_addresses.push_back("0.0.0.0"); } - for (auto & bind_address: bind_addresses) + if (!disable_tcp) { - int listen_fd = create_and_bind_socket(bind_address, listening_port ? listening_port : bind_port, listen_backlog, &listening_port); - fcntl(listen_fd, F_SETFL, fcntl(listen_fd, F_GETFL, 0) | O_NONBLOCK); - epmgr->set_fd_handler(listen_fd, false, [this](int fd, int events) + for (auto & bind_address: bind_addresses) { - msgr.accept_connections(fd); - }); - listen_fds.push_back(listen_fd); + int listen_fd = create_and_bind_socket(bind_address, listening_port ? listening_port : bind_port, listen_backlog, &listening_port); + fcntl(listen_fd, F_SETFL, fcntl(listen_fd, F_GETFL, 0) | O_NONBLOCK); + epmgr->set_fd_handler(listen_fd, false, [this](int fd, int events) + { + msgr.accept_connections(fd); + }); + listen_fds.push_back(listen_fd); + } } +#ifdef WITH_RDMACM + if (use_rdmacm) + { + for (auto & bind_address: bind_addresses) + { + auto listener = msgr.rdmacm_listen(bind_address, listening_port, &listening_port, log_level); + if (listener) + rdmacm_listeners.push_back(listener); + } + if (!rdmacm_listeners.size() && disable_tcp) + { + fprintf(stderr, "Failed to create RDMA-CM listeners, exiting\n"); + force_stop(1); + } + } +#endif } bool osd_t::shutdown() diff --git a/src/osd/osd.h b/src/osd/osd.h index cb51c21d..cb862ea8 100644 --- a/src/osd/osd.h +++ b/src/osd/osd.h @@ -109,6 +109,8 @@ class osd_t bool allow_net_split = false; std::vector cfg_bind_addresses; int bind_port, listen_backlog = 128; + bool use_rdmacm = false; + bool disable_tcp = false; // FIXME: Implement client queue depth limit int client_queue_depth = 128; bool allow_test_ops = false; @@ -202,6 +204,9 @@ class osd_t int listening_port = 0; std::vector bind_addresses; std::vector listen_fds; +#ifdef WITH_RDMACM + std::vector rdmacm_listeners; +#endif ring_consumer_t consumer; // op statistics diff --git a/src/osd/osd_cluster.cpp b/src/osd/osd_cluster.cpp index ab6cdfab..c2764754 100644 --- a/src/osd/osd_cluster.cpp +++ b/src/osd/osd_cluster.cpp @@ -172,6 +172,10 @@ json11::Json osd_t::get_osd_state() st["host"] = std::string(hostname.data(), hostname.size()); st["version"] = VITASTOR_VERSION; st["port"] = listening_port; +#ifdef WITH_RDMACM + if (rdmacm_listeners.size()) + st["rdmacm"] = true; +#endif st["primary_enabled"] = run_primary; st["blockstore_enabled"] = bs ? true : false; return st; diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt index e786f310..f32152df 100644 --- a/src/test/CMakeLists.txt +++ b/src/test/CMakeLists.txt @@ -25,6 +25,7 @@ target_link_libraries(stub_uring_osd vitastor_common ${LIBURING_LIBRARIES} ${IBVERBS_LIBRARIES} + ${RDMACM_LIBRARIES} tcmalloc_minimal )