WO2023221990A1 - Udp message distribution method, device and readable storage medium - Google Patents

Abstract

The present application discloses a UDP message distribution method, a device and a readable storage medium. When there are a plurality of process groups for one application service at the same time, each process group has an independent ebpf resource, the ebpf resources being used for storing information of a file handle (fd) of each process in the process groups. After receiving a UDP message, a server determines a target process group from amongst a plurality of process groups of a reuseport group on the basis of a four-tuple of the UDP message, selects a target fd from amongst fds of processes of the target process group, and transmits and receives data by means of the target fd. In the used solution, since each process group has the independent ebpf resource, processes in different process groups will not preempt the same fd, thereby avoiding distribution of UDP messages being in disorder when the plurality of process groups coexist, which achieves the purpose of ensuring service quality. Moreover, the problem of soft interrupt performance consumption caused by UDP connect can be further avoided, providing a high-concurrency capability.

Description

UDP message distribution method, equipment and readable storage medium

Cross-references to related applications

This application is filed based on a Chinese patent application with application number "202210556806.3" and a filing date of May 20, 2022, and claims the priority of the Chinese patent application. The entire content of the Chinese patent application is hereby incorporated by reference. Apply.

Technical field

The embodiments of this application relate to the field of Internet technology, and in particular to a method, device and readable storage medium for distributing UDP messages.

Background technique

User Datagram Protocol (UDP) is a connectionless transport layer protocol in the Open System Interconnect (OSI) reference model. With the development of technology, more and more streaming media protocols are implemented based on UDP.

Streaming media protocols implemented based on UDP include: Secure Reliable Transport (SRT) protocol, Web Real-Time Communication (WEBRTC) protocol, Quick UDP Internet Connections (QUIC) protocol, etc. Compared with Transmission Control Protocol (TCP), UDP has no concept of connection, is fast and has low reliability.

Nginx server is a high-performance Hyper Text Transfer Protocol (Hyper Text Transfer Protocol, HTTP) and reverse generation server, which has the characteristics of high concurrency, good performance and small memory usage. Nginx-based streaming media servers are widely used in streaming media technology. Multiple application services are deployed on the Nginx server, and multiple application services can run at the same time. Each application service corresponds to a group of processes, and a group of processes contains multiple processes. A group of processes uses the same UDP port to send and receive data.

However, it has been verified that when an application service is upgraded or hot updated, there will be two or more groups of processes. At this time, multiple groups of processes use the same UDP port to send and receive data, which will cause data confusion. For example, if there are two groups of processes, namely the old process group and the new process group, then the UDP packet originally distributed by the process in the new process group is distributed to the process in the old process group, or a UDP packet was originally distributed to processes in the old process group, but distributed to processes in the new process group.

Contents of the invention

This application provides a UDP message distribution method, equipment and readable storage medium. Each time a new process group is generated, ebpf resources are allocated to the new process group, so that each process group in multiple process groups has The independent ebpf resource ensures that UDP packet distribution will not be disrupted when multiple process groups coexist, achieving the purpose of improving service quality.

In the first aspect, embodiments of the present application provide a method for distributing UDP messages, including:

Receive UDP messages from terminal devices;

The target process group is determined from multiple process groups in the port multiplexing group according to the four-tuple carried in the UDP message. The multiple process groups are multiple process groups created in sequence for application services. The multiple processes Each process group in the group has independent ebpf resources;

Use the target fd to distribute the UDP message.

In the second aspect, embodiments of the present application provide a device for distributing UDP messages, including:

Transceiver module, used to receive UDP messages from terminal devices;

A processing module configured to determine a target process group from multiple process groups in the port multiplexing group based on the four-tuple carried in the UDP message. The multiple process groups are multiple process groups created sequentially for application services, Each process group in the plurality of process groups has independent ebpf resources;

A selection module, used to select the target fd from the fd of each process in the target process group;

A distribution module, configured to distribute the UDP message using the target fd.

In a third aspect, embodiments of the present application provide an electronic device, including: a processor, a memory, and a computer program stored on the memory and executable on the processor. When the processor executes the computer program, the The electronic device implements the method described in the above first aspect or various possible implementations of the first aspect.

In a fourth aspect, embodiments of the present application provide a computer-readable storage medium. Computer instructions are stored in the computer-readable storage medium. When executed by a processor, the computer instructions are used to implement the above first aspect or the first aspect. various possible implementations.

In a fifth aspect, embodiments of the present application provide a computer program product including a computing program. When the computer program is executed by a processor, the method described in the above first aspect or various possible implementations of the first aspect is implemented.

The UDP message distribution method, equipment and readable storage medium provided by the embodiment of this application, when multiple process groups of an application service exist at the same time, each process group has an independent ebpf resource, and the ebpf resource is used to save the process group. Information about the file handle fd of each process. After the server receives the UDP message, it determines the target process group from multiple process groups in the port multiplexing group based on the four-tuple of the UDP message, selects the target fd from the fd of each process in the target process group, and uses The target fd sends and receives data. Using this solution, since each process group has independent ebpf resources, processes in different process groups will not seize the same fd, ensuring that there will be no confusion in the distribution of UDP messages when multiple process groups coexist, ensuring service quality. the goal of. Moreover, it can also avoid the soft interrupt performance consumption problem caused by UDP connect, and has high concurrency.

Description of the drawings

In order to more clearly illustrate the technical solutions in the embodiments of the present application, the drawings needed to be used in the description of the embodiments will be briefly introduced below. Obviously, the drawings in the following description are only some embodiments of the present application. For those of ordinary skill in the art, other drawings can also be obtained based on these drawings without exerting creative efforts.

Figure 1 is a schematic diagram of the implementation environment of the UDP message distribution method provided by the embodiment of the present application;

Figure 2 is a flow chart of a UDP message distribution method provided by an embodiment of the present application;

Figure 3A is a schematic diagram of the relationship between UDP messages and process groups in the UDP message classification method provided by the embodiment of the present application;

Figure 3B is another schematic diagram of the relationship between UDP messages and process groups in the UDP message dividing method provided by the embodiment of the present application;

Figure 4 is a schematic structural diagram of a new module inside the server in the UDP message distribution method provided by the embodiment of the present application;

Figure 5 is a schematic diagram of a UDP message distribution device provided by an embodiment of the present application;

FIG. 6 is a schematic structural diagram of an electronic device provided by an embodiment of the present application.

Detailed ways

In order to make the purpose, technical solutions and advantages of the present application clearer, the embodiments of the present application will be further described in detail below with reference to the accompanying drawings.

Currently, Transmission Control Protocol (TCP) has high reliability but slow speed. UDP has low latency, weak network resistance and other properties, so it is widely used in audio and video transmission, such as live broadcast scenarios. UDP is different from TCP. UDP has no concept of connection. When the Nginx server uses UDP, multiple processes of an application service on the Nginx server use the same UDP port to send and receive data. Under normal circumstances, when an application service has not been hot updated or upgraded, an application service has a process group that contains multiple processes. Each process in this process group uses its own file handle. fd) There will be no problem in sending and receiving UDP messages. However, when application services are hot updated or upgraded, there will be two or more process groups at the same time, and each process group will preempt the fd, causing confusion in the sending and receiving of UDP packets. For example, a UDP message should be sent to a process in the new process group, but is sent to a process in the old process group; another example, a UDP message should be sent to a process in the old process group, but is sent to a process in the new process group. Processes in the process group cause the entire application service to be unavailable, affecting service quality.

In the live broadcast scenario, assuming that the host is pushing the stream, the push data should be sent to the processes in the old process group. When the above confusion occurs, the push stream will be disconnected, causing the live broadcast to be interrupted. In the same way, when the viewer pulls the stream, the terminal device sends a UDP message to the Nginx server to request the stream. The UDP message should be distributed to the processes in the new process group, but it is distributed to the process in the old process group, so the audience cannot watch. live streaming.

If the UDP connect method is used to solve the above-mentioned problem of chaotic UDP packet distribution, it will cause the problem of single-core soft interrupt performance consumption. Moreover, the concurrency capability of the UDP connect solution is low, about 500.

Based on this, embodiments of the present application provide a UDP message distribution method, device, and readable storage medium. Each time a new process group is generated, an Extended Berkeley packet filter (Extended Berkeley Packet Filter) is allocated to the new process group. Packet Filter (ebpf) resource enables each process group in multiple process groups to have independent ebpf resources, ensuring that UDP packet distribution will not be disrupted when multiple process groups coexist, thereby achieving the purpose of improving service quality.

Figure 1 is a schematic diagram of the implementation environment of the UDP message distribution method provided by the embodiment of the present application. Referring to FIG. 1 , the network architecture includes a terminal device 11 and a server 12 .

The terminal device 11 may be a terminal device on the host side or a terminal device on the viewing side, including but not limited to mobile phones and tablet computers installed with Android operating system, Microsoft operating system, Symbian operating system, Linux operating system or Apple iOS operating system. , personal computers, e-book readers, laptops, desktop computers, etc.

Server 12 may be hardware or software. When the server 12 is hardware, the server 12 is a single server or a distributed server cluster composed of multiple servers. When the server 12 is software, it may be multiple software modules or a single software module, etc., which is not limited by the embodiments of this application. The server 12 is an Nginx-based server, including but not limited to edge nodes in a content delivery network (Content Delivery Network, CDN).

The server 12 can provide multiple application services, and these application services can run at the same time. One application service corresponds to one UDP port, and one UDP port can have multiple process groups at the same time. Multiple process groups use the same UDP port to distribute UDP messages. This UDP port is the port reuse (reuseport) group. Reuseport is a feature of socket that supports multiple different fds to use the same UDP port to distribute UDP messages.

The purpose of this case is to solve the following problem: when multiple process groups exist at the same time and multiple process groups use the same UDP port to distribute UDP messages, how to ensure that the distribution of UDP messages will not be disordered. The reason why multiple process groups of an application service exist at the same time is to hot update or upgrade the application service. In addition, when a process in a process group becomes abnormal, based on this case, it can also be ensured that the distribution of UDP messages will not be disrupted. When multiple process groups exist at the same time, the abnormal process is the process in the newly created process group among the multiple process groups; when the application service has only one process group, the abnormal process is the process in this process group.

Server 12 uses ebpf to manage UDP data streams. The ebpf feature is supported on the new Linux kernel. By writing a business logic code in the application layer and implanting it into the kernel for operation, different business logic problems of different businesses can be solved without modifying the kernel code. It is truly pluggable. Compared with modifying the kernel code, the above method has the characteristics of fast cycle time and high security.

Server 12 initializes the ebpf resource in module initialization and loads the ebpf resource into the kernel. At the same time, consider the multi-port scenario, that is, multiple UDP ports. Each UDP port can be a reuseport group. Each UDP port has independent ebpf resources and does not interfere with each other. For example, UDP ports include port 80 and port 443. Port 80 has its own ebpf resource, and port 443 has its own ebpf resource. Port 80 can have multiple process groups, and port 443 can also have multiple process groups.

It should be understood that the number of terminal devices 11 and servers 12 in Figure 1 is only illustrative. In actual implementation, any number of terminal devices 11 and servers 12 can be deployed according to actual needs.

Next, based on the architecture shown in Figure 1, the UDP message distribution method described in the embodiment of the present application will be described in detail. For example, please refer to Figure 2.

Figure 2 is a flow chart of a UDP message distribution method provided by an embodiment of the present application. This embodiment is explained from the perspective of the server. This embodiment includes:

201. The server receives the UDP message from the terminal device.

The terminal device may be the anchor end or the audience's playback end, etc., which is not limited by the embodiments of this application. When the terminal device is the host, the UDP packet carries push data. After receiving the UDP packet, the server finds the target fd and uses the target fd to pass the push data carried in the UDP packet to the upper-layer worker process. When the terminal device is the playback end, the UDP message is used to request live broadcast data. After receiving the UDP message, the server determines the target fd based on the UDP message and uses the target fd to return the live broadcast data to the terminal device.

202. The server determines the target process group from multiple process groups in the port multiplexing group based on the four-tuple carried in the UDP message. The multiple process groups are multiple process groups created in sequence for the application service.

In this embodiment of the present application, the server can provide multiple application services, and these application services can run in parallel. Application services inevitably require hot updates or upgrades. Among them, hot update is also called reload, configuration update, hot reload, reload configuration, etc. It refers to dynamically loading configuration and updating parameters in the application service, but does not change the entire application service and does not upgrade the version of the application service. Upgrading refers to upgrading the version of an application service, that is, replacing the pre-upgraded application service with the upgraded application service.

After the server is started, a master process is created for an application service, and a group of worker processes are created by the master process. The Master process is responsible for managing the running status of the worker process. This group of worker processes is one of the multiple process groups in step 202. When an application service is hot updated, a new process group is generated every time it is reloaded. In order to ensure that the data on the old process will not be interrupted, the old process will not exit immediately, but will exit when the exit time is reached. This causes multiple process groups to exist at the same time after multiple reloads. Generally speaking, it will not reload multiple times in a row. However, sometimes operation and maintenance personnel are anxious to modify configurations, etc., and will reload multiple times, causing multiple process groups to exist at the same time. Each time it is reloaded, the main process remains unchanged, and the main process creates a group of worker processes.

In order to avoid multiple process groups occupying a large amount of resources at the same time, a first number is preset. The first number is used to indicate the maximum number of process groups in the port multiplexing group, which can be 5, 32, etc., this application The examples are not limiting.

It should be noted that the first number is used to represent the maximum number of process groups in a port multiplexing group, and does not represent the maximum number of reloads. For example, if the first number is 5, it means that a port multiplexing group can have up to 5 process groups at the same time. When 5 process groups exist at the same time, it is possible to reload 4, 5 or more times. This is because once processes exist simultaneously When the number of groups reaches the first number, when reloading next, the server will clean up the earliest created process group and related records, and then reload.

In the same way, a new process group will be created every time you upgrade. Different from reload, every time it is upgraded, the server creates a new master process, and the new master process creates a group of worker processes to obtain a new process group.

In the embodiment of this application, the server maintains a dynamic array, represented by reuseport array. The elements in this dynamic array are the ebpf resources of each process group. The number of elements is the same as the number of process groups that exist at the same time. One element corresponds to one process group. It can be seen that each process group has an independent ebpf resource, and the ebpf resource is used to maintain the fd of each process in the process group. For example, if there are two process groups at the same time, each process group contains 7 processes, then for any process group, 7 fds are stored in the ebpf resource of the process group, and different fds correspond to different processes.

Optionally, in some embodiments, the ebpf resource is used to save information about the file handle fd of each process in the process group, and the number of process groups in multiple process groups is greater than or equal to 2.

For example, after multiple reloads or upgrades, multiple process groups coexist, and the ebpf resource of a process group stores the fd of each process in the process group and some other resources.

In this embodiment of the present application, the server distinguishes clients (terminal devices that send UDP messages) based on four-tuple groups. Assume that before reload, UDP packets of a terminal device (terminal device 1) are distributed to processes in the old process group. Then, after reload, the UDP packets of this terminal device must be assigned to the old process group. After the new terminal device (Terminal Device 2) sends a UDP message, because the IP of Terminal Device 2 is different from the IP of Terminal Device 1, the UDP message of Terminal Device 2 is distributed to the new process group.

After the server receives the UDP message, it extracts four elements from the header of the UDP message, namely the source port number, source IP address, destination port number and destination IP address, and determines it from multiple process groups based on the four-tuple Target process group. Since each process group has independent ebpf resources, that is, different process groups have different fds, different process groups will not seize the same fd and will not cause confusion in UDP messages. That is to say, UDP packets originally distributed to the new process group will not be distributed to the old process group, and UDP packets originally distributed to the old process group will not be distributed to processes in the new process group.

For example, there are two process groups at the same time, which are process groups created before and after application service reload. The one created first is called the old process group, and the one created later is called the new process group. There are 7 processes in the old process group, and each process has its own fd. There are 7 fds in the new process, and each process also has its own fd. The fd of the new process is a newly generated fd, not an inherited fd of the old process. If the existing technology is used, since the new process group is generated by copying the old process group, the processes in the new process group inherit the fd of the processes in the old process group, resulting in a total of 14 processes in the new and old process groups, but only 7 fd, changes in hash mapping lead to data confusion. In the embodiment of this application, there are a total of 14 processes in the new process group and the old process group, but there are 14 FDs. Processes in different process groups will not preempt the same FD, so data confusion will not occur.

203. The server selects the target fd from the fds of each process in the target process group.

Figure 3A is a schematic diagram of the relationship between UDP messages and process groups in the UDP message classification method provided by the embodiment of the present application. Figure 3B is another schematic diagram of the relationship between UDP messages and process groups in the UDP message classification method provided by the embodiment of the present application.

Please refer to Figure 3A. When the four-tuple of a UDP message is the same as the four-tuple of the previously received UDP message, the UDP message is regarded as an old request, the target process group is the old process group, and the old request is Distributed to the old process group, the server determines the target fd from the fd of each process in the old process group.

Please refer to Figure 3B. When the quadruple of a UDP message is different from the quadruple of the previously received UDP message, the UDP message is regarded as a new request, the target process group is the new process group, and the new request is distributed to the new process group, and the server determines the target fd from the fd of each process in the new process group.

The server selects the target fd from the fds of each process included in the target process group based on the load balancing principle. For example, the server determines the process with a smaller load from the multiple processes included in the target process group, and uses the fd of this process as the target fd.

204. The server uses the target fd to distribute UDP messages.

When the UDP message is from the anchor side, the server uses the target fd to send push data to the upper worker process. When the UDP message is a request message from the viewer, the server obtains video data, etc. and responds to the viewer using the target fd.

In the UDP message distribution method provided by the embodiment of this application, when multiple process groups of an application service exist at the same time, each process group has an independent ebpf resource, and the ebpf resource is used to save the file handle fd of each process in the process group. information. After the server receives the UDP message, it determines the target process group from multiple process groups in the port multiplexing group based on the four-tuple of the UDP message, selects the target fd from the fd of each process in the target process group, and uses The target fd sends and receives data. Using this solution, since each process group has independent ebpf resources, processes in different process groups will not seize the same fd, ensuring that there will be no confusion in the distribution of UDP messages when multiple process groups coexist, ensuring service quality. the goal of. Moreover, it can also avoid the soft interrupt performance consumption problem caused by UDP connect, and has high concurrency.

Optionally, in some embodiments, each time a process group is created, the server uses the main process to create a second process group. The first process group and the second process group are two process groups created successively among multiple process groups. The first process group corresponds to the first group of fd. Afterwards, a second set of fds is generated for the second process group. Finally, set the second group of fd to the standby resources in the resource collection to obtain the ebpf resource of the second process group. The resource collection stores the pre-created standby resources. The first number of the standby resources in the resource set is The maximum number of process groups in the port multiplexing group is the same, and the second number of process groups in multiple process groups is less than or equal to the first number.

For example, in some embodiments, a resource collection is pre-created on the server, and pre-created resources to be used are stored in the resource collection. The number of resources to be used is the first number, and the first number is The maximum number of process groups in the above port multiplexing group. For example, if a port multiplexing group is preset to have up to 5 process groups at the same time, then the first number = 5. The number of process groups that currently exist at the same time can be 2, 3, 4 or 5. Of course, if reload or upgrade does not occur, there will only be one process group in a port multiplexing group.

Each time the server creates a new process group, it saves the latest process group number. For example, when there is only one process group, the sequence number of the process group is sequence number 1. After reload is executed for the first time to create a new process group, the serial number of the new process group is serial number 2, and so on. The process group is created by the application layer of the server, and the application layer is responsible for cleaning up the ebpf resources. Generally speaking, the number of processes in the new process group is the same as the number of processes in the old process group. However, the embodiment of the present application is not limited. The number of processes in the old process group may be equal to, less than, or more than the number of processes in the new process group.

Whether it is reload or upgrade, every time the server creates a new process group, the process group that already existed before the process group was created is the first process group, and the process group created this time is the second process group. Each time a second process group is created, the server uses the main process to create the second process group. The first process group and the second process group are two process groups created successively among multiple process groups. The first process group corresponds to The first set of fd. However, the processes in the second process group do not inherit the fds of the processes in the first process group, but generate new fds for each process in the second process group, that is, the second group of fds. After generating the second group of fd, the server takes out a standby resource from the resource collection and sets the second group of fd to the standby resource, thereby obtaining the ebpf resource of the second process group. Afterwards, the second grouped ebpf resource is stored as an element in the dynamic array (reuseport array).

Using this solution, each time a process group is created, the server generates a set of fds for the newly created process group and does not inherit the fds of the processes in the old process group, preventing multiple processes from seizing the same fd after the server receives a UDP message. , to ensure that UDP packets are sent without confusion.

Below, from the perspectives of reload and upgrade, we will describe in detail how to generate a new set of FDs for the new process group each time it is created.

First, reload the scene.

When performing a hot update on an application service to create a second process group, before the server generates the second group of fds for the second process group, it filters out the fds in the listening structure of the first process group, the first process group and the second process. Groups are created by the first main process.

In this scenario, the master process has not changed, so the second process group can obtain the listening structure of the first process group. For traditional Nginx-based servers, when an application service is hot updated, the fd of the process in the first process group will be closed, and the fd of each process in the first process group will be inherited by the corresponding process in the second process group. As a result, the fd of the first process group and the fd of the second process group are the same, and these two sets of fd cannot be set to the dynamic array (reuseport array). In this case, in order to ensure that the first group of fd of the first process group and the second group of fd of the second process group are different, when the ebpf flag in the listening structure (listening structure) of the first process group is currently ebpf mode When listening to the structure, the fd of the listening structure is not inherited, but filtered out and not passed to the second process group. Moreover, the fd of the process in the first process group is not closed.

Using this solution, for the reload scenario, filter out the fd in the listening structure of the first process group, so that the processes in the second process group do not inherit the fd of the first process group, but generate a group for the second process group. The new fd, that is, the second group of fd, ensures that the first group of fd and the second group of fd of the first process group are different, thereby preventing multiple processes from preempting the same fd during hot update and ensuring the distribution of UDP messages in the hot update scenario. There will be no confusion.

Secondly, upgrade the scene.

When an application service is upgraded to create a second process group, the first main process is used to pass environment variables to the second main process. The first main process is the main process before the application service is upgraded, and the second main process is after the application service is upgraded. the main process. Afterwards, when the fd carrying the preset identification exists in the environment variable, the server closes the fd carrying the preset identification. The preset identifier is used to indicate that the fd is the fd of ebpf.

In this scenario, the master process changes: it was the first master process before the upgrade, and it is the newly created second master process after the upgrade. The entire process space has changed and been replaced by a new executable program, making the second process group unable to Get the listening structure of the first process group. The newly created second process group is generated through the fork function and execv function. The fd of each process in the first process group is not closed. For traditional Nginx-based servers, for upgrade scenarios, the server passes all fds of the old listening structure of the first process group to the new main process, that is, the second main process, through environment variables. After the second main process obtains these fds through environment variables, it sets them in the listening structure of the second process group and continues to use them.

The difference between this case and the traditional solution is that in this case, when using environment variables to transfer fd, it distinguishes between ordinary fd and ebpf fd. For ebpf fd, a preset identification is added to the fd. The preset identification is, for example, b, etc. This application The examples are not limiting. For example, the fd passed by the environment variable includes 12, 13, b14 and 15. b14 indicates that the fd is the fd of ebpf, and the value is 14. After the second main process parses out the fd carrying the preset identifier, it closes the fd so that the second process group no longer inherits the fd. The server generates a new set of ebpf fd for the second process group and sets this set of fd to Obtain the ebpf resource of the second process group from a standby resource.

Using this solution, for the upgrade scenario, due to the change of the main process, the fd is passed and distinguished through the environment variable, and the fd carrying the preset identifier is closed so that the second process group does not inherit the fd, but generates a fd for the second process group. Group a new fd, that is, the second group of fd, to ensure that the first group of fd and the second group of fd in the first process group are different, thereby preventing multiple processes from preempting the same fd during the upgrade, and ensuring that the distribution of UDP packets in the upgrade scenario is not will be confused.

When upgrading, there may be a scenario where the upgrade fails. In this case, the server uses the first main process to create a third process group and closes the fd in the third process group's listening structure. Afterwards, the server generates a third group of fds for the third process group, and creates an ebpf resource corresponding to the third process group based on the third group of fds.

For example, if the upgrade fails, the old main process, that is, the first main process, starts a group of worker processes again, and this group of worker processes is the third process group. For example, an application service has a first process group. If the upgrade is successful, a new main process, that is, the second main process, creates a second process group. However, if the upgrade fails, the first main process will create a third process Engineering group. If the existing solution is adopted, since the first main process does not modify the listening structure of the first process group, the fd of the third process group is the same as the fd of the first process group, and problems will occur. Moreover, the first process group will exit when the exit time is reached. In the embodiment of this application, a group of fds, that is, the third group of fds, will be regenerated for the third process group, and the third group of fds will be set to a standby resource to obtain the ebpf resource of the third process group. That is to say, when the first main process creates the third process group, it obtains a new set of fds based on the third process group, that is, the third group of fds, and adds the third group of fds to the dynamic array (reuseport array) through the ebpf interface. . Subsequent new UDP messages are distributed to fd in the third process group, and then the third process group is started. The worker processes in the third process group use the new fd service.

Using this solution, when the upgrade fails, the old master process restarts a process group, and generates fd for the new process group so that the new process group has independent ebpf resources to ensure that UDP message distribution will not be disordered when the upgrade fails. phenomenon to achieve the purpose of improving business quality.

In the above embodiment, the focus is on how to ensure that the distribution of UDP messages will not be disordered when at least two process groups exist at the same time during reload and upgrade. There is another scenario: there is an abnormal process in the newly created process group among multiple process groups. This scenario will also cause confusion in the sending and receiving of UDP messages. Below, we provide a detailed explanation of how to solve the data confusion caused by abnormal processes.

After the server determines that an abnormal process exists in the newly created process group among multiple process groups, it creates a new worker process for the newly created process group. The fd of the worker process is the fd of the abnormal process.

For example, whether it is reload or upgrade, a process in the newly created process group may be abnormal due to the existence of bugs. This process is an abnormal process or a hung process. For example, the newly created process group contains 7 processes. When one of the 7 processes becomes abnormal, there are 6 normal processes left. If the existing technology is used, the hash table maintained by the server will be disordered, and thus This leads to confusion in UDP packet distribution. In this case, when an abnormal process occurs in the newly created process group, the main process (in the reload scenario, the main process is the first main process, in the upgrade scenario, the main process is the second main process) restarts a worker process, and the worker process Continue to use the fd of the abnormal process. In this way, the main process associates fd according to the sequence number of each process in the newly created process group, so that the re-created worker process can receive UDP messages.

When an abnormal process occurs in the old process group, the old process group will exit when the exit time is reached because a new process group has been created. Therefore, no processing is required by the server. The old process group is a process group among multiple process groups except the latest created process group. For example, 5 process groups exist at the same time, the 5th process group is the latest created process group, and the other 4 process groups are old process groups.

In addition, if reload or upgrade is not executed, there is only one process group, and there is also the phenomenon of abnormal processes. The processing method is the same, that is, the master process creates a new worker process, and the worker process inherits the fd of the abnormal process.

Using this solution, when an abnormal process occurs in the process group, the master process re-creates a worker process and uses the fd of the abnormal process to ensure that the distribution of UDP packets will not be disordered when an abnormal process occurs, thereby achieving the purpose of improving service quality.

Optionally, in some embodiments, the server maintains a dynamic array (reuseport array). Each time a process group is created, the server stores the ebpf resource of the process group created this time as an element in a dynamic array. When the number of elements in the dynamic array is greater than or equal to the first number, the server clears the elements of the first created process group in the order in which the process groups are created, and then adds the ebpf resources of the process group created this time. Stored in dynamic array.

For example, in the reload scenario, a new process group will be generated every time it is reloaded. Since the main process has not changed, the exit_master interface will not be called to clean up resources. Among them, the exit_master interface is an interface registered by the server to complete resource recycling.

The server pre-defines the first number, which is the maximum number of process groups that can exist at the same time. Each time a process group is created, the server stores the ebpf resource of the process group as an element in a dynamic array. When the number of elements in the dynamic array reaches the first number for the first time, it means that the resources to be used in the pre-created resource collection have been used up. When you create a process group again later, you need to clear the ebpf resource corresponding to the first created process group from the dynamic array to release the ebpf resource. In this way, after creating a new process group, the new process group will have ebpf resources. Available.

This solution is used to recycle ebpf resources for reload scenarios to ensure that application services can be reloaded multiple times. By hot updating application services in a timely manner, the purpose of improving service quality is achieved.

For the upgrade scenario, every time a new process group is created and the master process changes, the new master process calls the exit_master interface to clean up resources. By cleaning up resources in a timely manner, it ensures that the application service can be upgraded multiple times, and the application service is upgraded in a timely manner. , to achieve the purpose of improving service quality.

In the above embodiments, when there are at least two process groups in a port multiplexing group on the server, how to ensure that the distribution of UDP messages will not be disordered. However, if there are multiple UDP ports on a server, each UDP port can be used as a port reuse group. For each port multiplexing group, the server uses the UDP message distribution method described in the embodiment of this application to distribute UDP messages, so there will be no problem of data confusion.

In addition, streaming media protocols implemented based on UDP include SRT, QUIC, etc. Multiple UDP ports can be configured for one protocol, and different protocols have different UDP ports. Each UDP port corresponds to an ebpf resource. If there are multiple UDP ports, multiple copies of ebpf resources need to be loaded into the kernel. At the same time, the ebpf resources of each port are stored in different paths.

Moreover, different ports are distinguished by port multiplexing groups, and port multiplexing groups are based on IP + port. Therefore, when the same port can be bound to at least two IP protocols, the port multiplexing group simultaneously serves at least Two IP protocols.

For example, if the UDP port is port 10080, and the UDP port is bound to both IPv4 and IPV6, the UDP port can be regarded as two multiplexed ports, one serving IPV4 and the other serving IPV6.

Using this solution, by supporting multiple ports, multiple port reuse groups can be created based on one UDP port, which is highly flexible.

The UDP message distribution method provided by the embodiment of this application is universal and can be applied to streaming media protocols such as SRT, QUIC, WEBRTC, etc., and can solve the problem of data confusion caused by multiple process groups using the same UDP port to distribute UDP messages. . Below, taking SRT as an example, the UDP message sending method described in the embodiment of this application will be described in detail. For example, please refer to Figure 4, which is a schematic structural diagram of a new module inside the server in the UDP message distribution method provided by the embodiment of the present application.

Please refer to Figure 4. When the server is used for SRT, compared with the traditional server, in addition to the SRT module (ngx_srt_moudle), the ebpf module (ngx_core_bpf_moudle) is added to the server to complete ebpf related processing. The ebpf module registers two interfaces, one is the initialization interface (ngx_core_bpf_int_moudle), and the other is the resource recycling interface (ngx_core_bpf_exit_moudle_). The initialization interface is used to complete the initialization and loading of ebpf resources, and the resource recycling interface is used to complete resource recycling. Since this case is mainly to solve the problem of chaotic UDP packet distribution caused by multiple process groups using the same port multiplexing group, in master-worker mode, all ebpf operations must be completed by the master process.

In this case, a reuseport group will have a listening structure, and the listening structure has a socket address (sockaddr). If the sockaddr of the two listening structures is the same, then the two listening structures correspond to a reuseport group. If two If the sockaddr of the listening structures is different, the two listening structures correspond to different reuseport groups. A UDP port may have one, two or more reuseport groups. The server adds a preset identifier in the listening structure of a reuseport group, indicating that the reuseport group uses the solution of the embodiment of this application to distribute UDP messages.

In the embodiment of this application, in order to enable the server to implement the above-mentioned UDP message distribution method, the main modifications include the following five points:

1. Module initialization work.

The server performs initialization operations in the initialization interface, and ebpf has requirements for the server's kernel version. If the server's kernel version is too low, the UDP message distribution method in this case is not supported. Therefore, the server needs to first determine the kernel version. For example, the uname system call method is used to determine whether the kernel supports it. If the kernel does not support it, the traditional UDP-based connect method is used. If the kernel supports it, the UDP message distribution method described in the embodiment of this application is used.

If the kernel version supports it, the server selects the target process group from multiple process groups through a quadruple. An application service can have multiple process groups at the same time. The fd of each process in a process group is a group of fd, which is regarded as an ebpf resource. When the quadruple of a UDP message is a new quadruple, the UDP message is a new request, and the new request obtains the target fd from the new process group; when the quadruple of a UDP message is the old quadruple group, the UDP message is an old request, and the target fd is obtained from the old process group. Every time the server creates a new process group, it needs to save the latest sequence number of the process group. Compare For example, if there is currently a process group, the sequence number is 1. Executing a reload will generate a new process group, and the sequence number of the new process group will be 2, and so on.

The new process group is created by the application layer, which is responsible for cleanup work. The ebpf program works in the kernel. Set up ebpf related resources in the module initialization function, such as dynamic array (reuseport array), and then load the ebpf program into the kernel.

In the reload scenario, the master process has not changed and is still the current master process. There is no need to load the ebpf program again when reloading. Therefore, the fd of ebpf needs to be saved. When reloading multiple times, only the previous fd needs to be loaded. The saving method adopts file system association method, using bpf_obj_pin and bpf_pin_get methods. For example, the path that maps the handle of the ebpf program to the file system is: /sys/fs/bpf/udp_reuseport/udp_reuseport_prog. The saving paths for different reuseport groups are different.

2. Core code modification.

In this case, the server is based on Nginx. Nginx is an open source component and requires some modifications to the open source component.

Because UDP has no concept of connection, when there are multiple processes, each process has an fd, and one process and one fd serves multiple clients. When reload or upgrade is performed, an application service will have multiple process groups at the same time. The fd in the old process group continues to serve old requests, and new requests are served by the fd in the new process group. For traditional Nginx-based servers, when reloading or upgrading an application service, the fd of each old process in the old process group will be closed. In this case, by modifying the Nginx component, when reloading or upgrading the application service, the fd of each process in the old process group is not closed. For example, if the above default flag is 1, it means that the server's kernel version supports ebpf. At this time, every time a new process group is created, the fd of each process in the old process group will not be closed.

For traditional Nginx-based servers, when an application service is reloaded or upgraded, the fd of the listening structure of the old process group will be passed to the listening structure of the new process group through inheritance, resulting in the same fd of the two process groups. Cannot be set to a dynamic array (reuseport array). For this reason, in the embodiment of this application, when the kernel version supports ebpf and the server adopts the UDP message distribution method of this application, each time a new process group is created, the fd in the old process group will not be inherited, but the old one will be filtered out. fd in the listening structure of the process group. The specific method is to pass the fd carrying the preset identifier in the old cycle (old cycle) without passing it to the new cycle (cycle). The listening structure is used to store listening information and is created by the master process. Each worker process has a listening structure. The listening information stored in the listening structure is, for example, fd, etc. In this case, every time a new process group is created, the processes in the new process group do not inherit the fd of the processes in the old process group.

When performing an upgrade, it is different from reload. Because the main process has not changed during reload, you can get the listening structure of the old process. However, when performing an upgrade, the main process changes. The new main process is generated through fork+execv. The new main process will inherit all the monitored fds of the old main process. When the new main process creates a new process group, it is shut down Inherited fd, and generate a new fd for the new process group. In the traditional solution, the server passes all the fds of the old process group's listening structure to the new master process through environment variables. After the new master process obtains the fds through environment variables, it is used by the new process group. This allows different processes in the two process groups to use the same fd. In this case, the transfer and setting of fd are modified. During the transfer process, in order to distinguish the ordinary fd from the fd of ebpf, a preset identifier is added in front of the fd of ebpf. The preset identifier is, for example, b, etc. This application embodiment is not limited. For example, the passed fd includes 12, 13, b14 and 15, where b14 represents the fd of ebpf and the value is 14. After the new master process parses the fd of ebpf, it closes the fd. The new process group does not inherit the fd. The new master process generates a new set of fd for the new process group, and then adds the new fd of the group to the dynamic in the reuseport array.

If the upgrade fails, the old master process starts a group of worker processes again, that is, the third process group. In this scenario, because the old master process did not modify the fd of the first process group, the fd of the third process group is still the fd of the first process group. The fds of these two process groups are the same, and the fd of the third process group cannot be changed. fd is set to a dynamic array. For this reason, in this case, the fd in the listening structure of the third process group is closed, a group of fd is regenerated for the third process group, that is, the third group of fd, and the third group of fd is set to a dynamic array, and subsequent new The request obtains the target fd in the third group of fd, and then starts the worker process in the third process group. These newly started worker processes can use the new fd service.

In this case, since there are multiple process groups in a reuseport group, each process in each process group has its own fd to process UDP packets, so at the bottom level, the kernel uses ebpf to ensure that UDP packets reach the corresponding process. Then the UDP messages of each client are distinguished by four-tuple within the process. The process decides whether a UDP packet goes to the new process or the old process. After the UDP packet reaches the process, the application layer distinguishes different connections based on the maintained client information.

3. Solve abnormal scenarios.

In the embodiment of this application, abnormal scenarios include: reload, upgrade and process exception.

For reload scenarios, the version of the application service will not change, but parameters, etc. will be updated. The main process will not exit and the configuration will be reloaded. Every time a new process group is created, the main process creates a second process group based on the first process group, and generates a new set of fd for the second process group, so that the fd of the first process group and the second process group are different. Each process group receives UDP messages through its own fd to ensure that the distribution of UDP messages will not be chaotic.

For the upgrade scenario, the application service is upgraded and the new version of the application replaces the old version of the application. The new main process loads a new version of the executable program, and then the new main process creates a new set of fd and a new process group. Since traditional Nginx will set up fd inheritance, the fd of the old process group will be inherited to the new process group, which is no problem for TCP. However, for UDP, because ebpf is used, a set of fds needs to be set for each process group to ensure that these process groups serve at the same time. Otherwise, if the fds of two or more process groups are the same, UDP message distribution chaos will occur. . Therefore, in the embodiment of this application, the new process group does not inherit the fd of the old process group, but creates a new set of fd for the new process group, loads the newly created fd into the kernel, and then each process group passes Its own fd distributes UDP messages.

For process exception (coredump) scenarios, the fd of each worker process is uniformly allocated in the master process, and then loaded into and associated with ebpf through the kernel interface. At this time, the kernel maintains a group of fds. These fds internally listen to the same port through reuseport to ensure that the data will not be confused. When a worker process dies, the master process will restart a new worker process, and the fd is still the hung process, that is, the fd of the abnormal process. The main process will associate the previous fd according to the sequence number of each worker process, so the restarted process can still receive UDP messages.

4. Multi-port problem.

In the embodiment of this application, one streaming media protocol can be configured with multiple ports, and different protocols are configured with different ports. The protocols include SRT, QUIC, etc. In this way, there will be multiple reuseport groups on the server. Different reuseport groups correspond to different ebpf resources, and different reuseports correspond to different UDP ports or the same UDP port. For example, port 123 is a port that supports SRT, port 123 is a reuseport group, port 111 is a port that supports QUIC, and port 111 is a reuseport group. For another example, if port 10080 is bound to both IPv4 and IPv6, then port 10080 corresponds to two reuseport groups, and port 10080 serves both IPv4 and IPv6. When there are multiple reuseport groups, each reuseport group in the multiple reuseport groups has its own ebpf resource, and each reuseport group has multiple process groups, and each process group also has independent ebpf resources.

When there are multiple reuseport groups, the ebpf resources of each reuseport group need to be loaded into the kernel. At the same time, it is necessary to distinguish when setting the association between ebpf resources and file systems, which can be distinguished by naming:

/sys/fs/bpf/udp_reuseport_10080/udp_reuseport_prog indicates port 10080;

/sys/fs/bpf/udp_reuseport_10081/udp_reuseport_prog indicates port 10081.

In this case, different UDP ports are distinguished by reuseport groups, and reuseport groups are distinguished by IP+Port. When a UDP port is bound to two or more IP protocols, one UDP port can create two or more reuseport groups. For example, when the above port 10080 is bound to IPv4 and IPv6, two reuseport groups will be created, and each group will go through the ebpf process.

The server traverses the listening structure and determines the sockaddr in each listening structure. If the sockaddr is the same, the ports corresponding to the two listening structures are considered to be the same reuseport group and are loaded into ebpf together. Each reuseport group has multiple process groups, each process group has multiple processes, and each process has its own fd.

5. Resource recycling issues.

Please refer to Figure 4. The ebpf module has registered two interfaces, namely the initialization interface and the resource recycling interface. The resource recycling interface is responsible for the cleaning operation of ebpf resources. In the Upgrade scenario, the main process will change. Each time a new process group is created, the ebpf module calls the resource recycling interface to recycle resources.

In the reload scenario, each reload will generate a set of ebpf resources to save the fd information of each process in the new process group. This group of fd will subsequently be set to standby resources to generate ebpf resources for the new process group. But due to The main process has not changed, so the resource recycling interface will not be called for cleaning, causing resources to be leaked every time they are reloaded. In order to clean up this set of resources, the traditional solution is to clean up after all worker processes have exited. If the worker process is cleared before it exits, the worker process will be unable to serve. However, in the existing solution, there is no mechanism to obtain the exit timing of all worker processes in a process group. Because the server supports multiple reloads, the old process group may not end during each reload. The exit timing of each worker process is different, so there is no way to know which worker processes belong to a group.

In this case, the elements in the dynamic array cannot exceed the first number. The first number is, for example, 5. This is not limited by the embodiment of the present application. Once the number of elements exceeds the first number, it needs to be cleaned up to ensure that the number of elements that exist at the same time is less than or equal to the first number, that is, the number of process groups that exist at the same time is less than or equal to the first number. For example, the first number is 5, which means that up to 5 process groups can exist at the same time, and the sequence numbers are 0, 1, 2, 3, and 4 respectively. Each time a group of fds is created for a new process group, and an ebpf resource is obtained, the ebpf resource is stored as an element in a position of the dynamic array. Before saving, determine whether the position is empty. If it is not empty, first clean up the elements originally held at the position, and then save the element created this time to this position. There are 5 positions in the dynamic array, namely position 0 to position 4. When elements are saved at positions 0 to 4, the elements created by reload will be placed at position 0. Since position 0 is not empty, the ebpf resource process corresponding to position 0 will be cleaned up, such as releasing memory and other operations, and will be closed. fd of ebpf resource. Then, store the newly created element at position 0.

The following are device embodiments of the present application, which can be used to execute method embodiments of the present application. For details not disclosed in the device embodiments of this application, please refer to the method embodiments of this application.

Figure 5 is a schematic diagram of a UDP message distribution device provided by an embodiment of the present application. The UDP message distribution device 500 includes: a transceiver module 51 , a processing module 52 , a selection module 53 and a distribution module 54 .

Transceiver module 51, used to receive UDP messages from terminal devices;

The processing module 52 is configured to determine a target process group from multiple process groups in the port multiplexing group according to the quadruple group carried in the UDP message. The multiple process groups are multiple process groups created sequentially for the application service. The multiple processes Each process group in the group has independent ebpf resources;

The selection module 53 is used to select the target fd from the fd of each process in the target process group;

Distribution module 54 is used to distribute UDP messages using the target fd.

In a feasible implementation, before the processing module 52 determines the target process group from multiple process groups in the port multiplexing group according to the quadruple carried in the UDP message, it is also used to use the main process each time a process group is created. Create a second process group. The first process group and the second process group are two process groups created successively among the plurality of process groups. The first process group corresponds to the first group of fd; generate a second group for the second process group. fd; set the second group of fd to the resources to be used in the resource collection to get ebpf resource, the resource collection stores pre-created resources to be used. The first number of the resources to be used in the resource collection is the same as the maximum number of process groups in the port multiplexing group. The second number of process groups in multiple process groups The number is less than or equal to the first number.

In a feasible implementation, before the processing module 52 generates the second group of fd for the second process group, it is also used to filter out the listening structure of the first process group when performing a hot update on the application service to create the second process group. In the fd in the body, the first process group and the second process group are both created by the first main process.

In a feasible implementation, the processing module 52 is also used to store the ebpf resource of the process group created this time as an element in a dynamic array after each process group is created; when the number of elements in the dynamic array is greater than or equal to the first number, after cleaning the elements of the first created process group in the order in which the process groups among multiple process groups are created, the ebpf resources of the process group created this time are stored in a dynamic array.

In a feasible implementation, before the processing module 52 generates the second group of fd for the second process group, it is also used to use the first main process to the second main process when upgrading the application service to create the second process group. Pass the environment variable. The first main process is the main process before the application service upgrade, and the second main process is the main process after the application service upgrade. When there is an fd carrying a preset identification in the environment variable, close the fd carrying the preset identification. .

In a feasible implementation manner, the processing module 52 is also used to call the resource recovery interface to clean up the ebpf resources of the first process group each time the process group is created.

In a feasible implementation, the processing module 52 is also used to use the first main process to create a third process group when the application service upgrade fails; close the fd in the listening structure of the third process group; target the third process The group generates the third group of fd; create the ebpf resource corresponding to the third process group based on the third group of fd.

In a feasible implementation, the processing module 52 is also used to determine that there is an abnormal process in the latest created process group among multiple process groups; create a new worker process for the newly created process group, and the file handle of the worker process is abnormal. fd of the process.

In a feasible implementation manner, when the UDP port corresponding to the port multiplexing group is bound to at least two IP protocols, the UDP port serves at least two IP protocols at the same time.

[0145] In a feasible implementation manner, the ebpf resource is used to save the information of the file handle fd of each process in the corresponding process group, and the number of process groups in multiple process groups is greater than or equal to 2.

The UDP message distribution device provided by the embodiment of the present application can perform the actions of the server in the above embodiment. Its implementation principles and technical effects are similar and will not be described again here.

FIG. 6 is a schematic structural diagram of an electronic device provided by an embodiment of the present application. As shown in Figure 6, the electronic device 600 is, for example, the above-mentioned control center or anti-attack node. The electronic device 600 includes:

Processor 61 and memory 62;

Memory 62 stores computer instructions;

The processor 61 executes the computer instructions stored in the memory 62, so that the processor 61 executes the UDP message distribution method implemented by the server as above.

The specific implementation process of the processor 61 can be found in the above method embodiments. The implementation principles and technical effects are similar and will not be described again in this embodiment.

Optionally, the electronic device 600 further includes a communication component 63 . Among them, the processor 61, the memory 62 and the communication component 63 can be connected through the bus 64.

Embodiments of the present application also provide a computer-readable storage medium. Computer instructions are stored in the computer-readable storage medium. When the computer instructions are executed by a processor, they are used to implement the UDP message distribution method implemented by the server as above.

Embodiments of the present application also provide a computer program product. The computer program product includes a computer program. When the computer program is executed by a processor, the UDP message distribution method implemented by the server is implemented as above.

Other embodiments of the present application will be readily apparent to those skilled in the art from consideration of the specification and practice of the application disclosed herein. This application is intended to cover any variations, uses, or adaptations of this application that follow the general principles of this application and include common knowledge or customary technical means in the technical field that are not disclosed in this application. . It is intended that the specification and examples be considered as exemplary only, with a true scope and spirit of the application being indicated by the following claims.

It is to be understood that the present application is not limited to the precise structures described above and illustrated in the accompanying drawings, and that various modifications and changes may be made without departing from the scope thereof. The scope of the application is limited only by the appended claims.

Claims (12)

A UDP message distribution method, including: Receive UDP messages from terminal devices; The target process group is determined from multiple process groups in the port multiplexing group according to the four-tuple carried in the UDP message. The multiple process groups are multiple process groups created in sequence for application services. The multiple processes Each process group in the group has independent ebpf resources; Select the target fd from the fd of each process in the target process group; Use the target fd to distribute the UDP message. The method according to claim 1, wherein before determining the target process group from multiple process groups in the port multiplexing group according to the quadruple carried in the UDP message, it further includes: Each time a process group is created, the main process is used to create a second process group. The first process group and the second process group are two process groups created successively among the plurality of process groups. The first process group corresponds to The first group fd; Generate a second group of fds for the second process group; The second group of fd is set to the standby resources in the resource set to obtain the ebpf resource. The resource set stores pre-created standby resources. The first standby resource in the resource set is The number is the same as the maximum number of process groups in the port multiplexing group, and the second number of process groups in the plurality of process groups is less than or equal to the first number. The method according to claim 2, wherein before generating the second group of fd for the second process group, the method further includes: When hot updating is performed on the application service to create the second process group, the fd in the listening structure of the first process group is filtered out. The first process group and the second process group are both composed of The first main process is created. The method according to claim 2 or 3, further comprising: Each time a process group is created, the ebpf resource of the process group created this time is stored as an element in a dynamic array; When the number of elements in the dynamic array is greater than or equal to the first number, after cleaning the elements of the first created process group according to the creation order of the process groups among the multiple process groups, the process group created this time will be The ebpf resources are stored in the dynamic array. The method according to claim 2, wherein before generating the second group of fd for the second process group, the method further includes: When the application service is upgraded to create the second process group, the first main process is used to transfer environment variables to the second main process. The first main process is the main process before the application service is upgraded, so The second main process is the main process after the application service is upgraded; When the fd carrying the preset identification exists in the environment variable, the fd carrying the preset identification is closed. The method of claim 5, further comprising: Each time a process group is created, the resource recovery interface is called to clean up the ebpf resources of the first process group. The method according to claim 5 or 6, further comprising: When the application service upgrade fails, use the first main process to create a third process group; Close the fd in the listening structure of the third process group; Generate a third group of fds for the third process group; Create the ebpf resource corresponding to the third process group according to the third group of fd. The method according to any one of claims 1-7, further comprising: Determine that there is an abnormal process in the latest created process group among the multiple process groups; Create a new worker process for the newly created process group, and the file handle fd of the worker process is the fd of the abnormal process. The method according to any one of claims 1-8, wherein, When the UDP port corresponding to the port multiplexing group is bound to at least two IP protocols, the UDP port serves the at least two IP protocols at the same time. The method according to any one of claims 1-9, wherein, The ebpf resource is used to save information corresponding to the file handle fd of each process in the process group, and the number of process groups in the plurality of process groups is greater than or equal to 2. An electronic device, including a processor, a memory, and a computer program stored on the memory and executable on the processor. When the processor executes the computer program, the electronic device implements the method of claim 1 Methods described in any one of -9. A computer-readable storage medium on which a computer program is stored. When the computer program is executed by a processor, the method according to any one of claims 1-9 is implemented.