WO2015109708A1

WO2015109708A1 - Data packet processing method and device, and server

Info

Publication number: WO2015109708A1
Application number: PCT/CN2014/078563
Authority: WO
Inventors: 王魏强; 朱志勇
Original assignee: 中兴通讯股份有限公司
Priority date: 2014-01-24
Filing date: 2014-05-27
Publication date: 2015-07-30
Also published as: CN104811391A; CN104811391B

Abstract

Disclosed are a data packet processing method and device, and a server. The method comprises: in response to a request for receiving data packets in batches, receiving, by a protocol stack, a plurality of data packets through an inner core debugging mechanism of an operating system, and returning the plurality of data packets after the number of the plurality of data packets is greater than a pre-set batch threshold value. The present invention solves the problem in the related art that the resource consumption of a protocol stack is large, and has the beneficial effect of reducing the resource consumption.

Description

TECHNICAL FIELD The present invention relates to the field of communications, and in particular to a method, an apparatus, and a server for processing a data packet. BACKGROUND In a streaming media server application based on a Linux operating system, a code stream needs to be forwarded. In this process, a data stream is received, and a received data message occupies a large amount of CPU resources, thereby improving the receiving performance and directly improving the server. Processing performance. 1 is a flowchart of a method for receiving a data packet according to the related art. In the related art, for each audio stream, a network socket is required to invoke a User Data Protocol (UDP) packet. The receiving interface receives data from the protocol stack. Each time a user process receives a data packet, it needs to use a system call. Each time the system call needs to be switched from the user state to the kernel state, the system call returns, and then the kernel state is switched to the user state. In the case that the streaming media server is heavily loaded, a large amount of data copying and context switching operations are triggered, which greatly consumes the CPU resources of the system and reduces the processing capability of the system. It can be seen from the above process that in the related art, when the user process receives each data packet, the system needs to be called once to enable the system to receive the data packet, thereby causing frequent system calls, greatly consuming CPU resources, and thereby reducing the performance of the entire system. Reduce the quality of the entire streaming service. In view of the problem that the resource consumption caused by the frequent calling of the system when the user process acquires the data packet in the related art, an effective solution has not been proposed yet. SUMMARY OF THE INVENTION Embodiments of the present invention provide a method, an apparatus, and a server for processing a data packet to solve at least the foregoing problems. According to an aspect of the embodiments of the present invention, a method for processing a data packet is provided, including: receiving, by a protocol stack, a request for receiving a data packet in batches, receiving a plurality of data packets through a kernel debugging mechanism of an operating system; After the number of packets is greater than the preset batch threshold, the multiple packets are returned. Advantageously, receiving the plurality of data packets by the kernel debugging mechanism of the operating system comprises: receiving the plurality of data packets by a jprobe mechanism provided by a kernel of the operating system. Preferably, receiving, by the jprobe mechanism provided by the kernel of the operating system, the plurality of data packets comprises: adding a batch receiving data packet function to a receiving interface of the protocol stack by using a jprobe management method; The batch receiving packet function receives the plurality of data packets. Preferably, the request by the protocol stack to receive the data packet in batch includes: the protocol stack responding to the request of the user process for receiving the data packet in batches. Preferably, after the number of the multiple data packets is greater than the preset batch threshold, returning the multiple data packets includes: determining whether the number of the multiple data packets received in a receive queue of a kernel state is If the number of the plurality of data packets is greater than the preset batch threshold, copying the plurality of data packets in the receive queue of the kernel state to the data of the user state. a buffer, wherein the user state corresponds to the user process, and the kernel state corresponds to the protocol stack. According to another aspect of the embodiments of the present invention, a processing apparatus for a data packet is provided on a protocol stack, including: a control module, configured to receive a plurality of requests for obtaining a data packet in batches, and receive multiple by a kernel debugging mechanism of an operating system a data packet; a return module, configured to return the plurality of data packets after the number of the plurality of data packets is greater than a preset batch threshold. Preferably, the control module is further configured to receive the plurality of data packets by a jprobe mechanism provided by a kernel of the operating system. Preferably, the control module includes: a setting unit configured to increase a batch receiving data packet function in a receiving interface of the protocol stack by using a jprobe management method; and a receiving unit configured to invoke the batch receiving data packet function Receiving the plurality of data packets. Preferably, the control module is further configured to receive a request for a data packet in response to a batch of user processes. Preferably, the returning module includes: a determining unit, configured to determine whether the number of the plurality of data packets received in the receiving queue of the kernel state is greater than the preset batch threshold; the copying unit is set to be in the If the number of the plurality of data packets is greater than the preset batch threshold, copying the plurality of data packets in the receive queue of the kernel state to the data buffer of the user state, where the user state is Corresponding to the user process, the kernel state corresponds to the protocol stack. According to still another aspect of the embodiments of the present invention, a server is provided, including a protocol stack, where the protocol stack includes the apparatus described in any one of the above. According to the embodiment of the present invention, the protocol stack is configured to receive multiple data packets in response to the batch request, and receive multiple data packets through the kernel debugging mechanism of the operating system, and return multiple after the number of multiple data packets is greater than a preset batch threshold. The data packet solves the problem that the protocol stack resource consumption in the related art is large, thereby achieving the effect of reducing resource consumption. BRIEF DESCRIPTION OF THE DRAWINGS The accompanying drawings, which are set to illustrate,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, In the drawings: FIG. 1 is a flowchart of a method of receiving a data packet according to the related art; FIG. 1a is a flowchart of a data packet processing method according to an embodiment of the present invention; FIG. 2 is a packet processing according to an embodiment of the present invention. FIG. 3 is a schematic structural diagram of a data packet processing apparatus according to an embodiment of the present invention; FIG. 4 is a schematic structural diagram 3 of a data packet processing apparatus according to an embodiment of the present invention; FIG. FIG. 6 is a flowchart of a packet processing method 1 according to a preferred embodiment of the present invention; and FIG. 7 is a flowchart of a packet processing method 2 according to a preferred embodiment of the present invention. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS Hereinafter, embodiments of the present invention will be described in detail with reference to the accompanying drawings. It should be noted that the embodiments in the present application and the features in the embodiments may be combined with each other without conflict. The embodiment of the present invention provides a method for processing a data packet, and FIG. 1a is a flowchart of a data packet processing method according to an embodiment of the present invention. As shown in FIG. 1a, the method includes the following steps: Step S102, the protocol stack responds to the batch. Receiving a request for a data packet, receiving a plurality of data packets through a kernel debugging mechanism of the operating system; Step S104: After the number of the plurality of data packets is greater than a preset batch threshold, returning the plurality of data packets. Through the above steps, the method of calling the operating system protocol stack once every time a user process receives a data packet in the related art is changed, which solves the problem that the user process needs to frequently call the system when the user process acquires the data packet in the related art. The problem has the beneficial effect of reducing resource consumption. In a preferred embodiment of the embodiment of the present invention, the step of acquiring a plurality of data packets by using a kernel debugging mechanism of the operating system may include: receiving a plurality of data packets by using a jprobe mechanism provided by a kernel of the operating system. Through the above steps, the existing protocol stack structure and the user state code can be used to implement the efficient batch collection by using the jprobe mechanism provided by the kernel without modifying the existing protocol stack structure, and the method can effectively reduce the system call and improve the receiving performance. Effectively reduce the amount of code modifications. In a preferred embodiment of the present invention, the step of receiving the plurality of data packets by using the jprobe mechanism provided by a kernel of the operating system may include: using a jprobe management method, and a receiving interface of the protocol stack Increase the batch receive packet function; call the batch receive packet function to receive multiple packets. Through the above steps, the kernel processing flow can be flexibly increased without modifying the kernel code, and it is convenient, quick, and less influential. In a preferred embodiment of the present invention, after the number of the plurality of data packets is greater than the preset batch threshold, the step of returning the multiple data packets to the user process may include: determining, by the protocol stack, the kernel-state receiving queue Whether the number of received multiple data packets is greater than a preset batch threshold, and if the number of the multiple data packets is greater than the preset batch threshold, copying multiple data packets in the kernel state receiving queue To the user-mode data buffer, where the user state corresponds to the user process, and the kernel state corresponds to the protocol stack. Through the above steps, the efficiency of receiving the data packet is improved, and the number of kernel state and user state switching is reduced to l/n, where n is the number of received data packets. In a preferred embodiment of the embodiment of the present invention, the operating system may be a Linux system, and the data packet may be a streaming media data packet. Of course, in other embodiments, other operating systems, such as Android, may also be other types of data packets, such as data packets for voice communication of mobile terminals.

The processing device of the data packet is also provided in the embodiment, and the device is configured to implement the above-mentioned embodiments and preferred embodiments, and the description thereof has been omitted. As used hereinafter, the term "module" may implement a combination of software and/or hardware of a predetermined function. Although the apparatus described in the following embodiments is preferably implemented in software, hardware, or a combination of software and hardware, is also possible and conceivable. The device is located on the protocol stack. FIG. 2 is a schematic structural diagram 1 of a data packet processing apparatus according to an embodiment of the present invention. As shown in FIG. 2, the apparatus includes: The control module 22 is configured to receive a plurality of data packets through a kernel debugging mechanism of the operating system in response to the request for obtaining the data packet in batches, and return to the module 24, and set to return more after the number of the plurality of data packets is greater than a preset batch threshold. Packets. Preferably, control module 22 is further configured to receive a plurality of data packets through a jprobe mechanism provided by a kernel of the operating system. Preferably, as shown in FIG. 3, the control module 22 may further include: a setting unit 222 configured to add a batch receiving data packet function in the receiving interface of the protocol stack by using a jprobe management method; the receiving unit 224 is set to be called Receive packet functions in batches and receive multiple packets. Preferably, as shown in FIG. 4, the returning module 24 may further include: a determining unit 242, configured to determine whether the number of the plurality of data packets received in the receiving queue of the kernel state is greater than a preset batch threshold; the copying unit 244, Set to copy multiple packets in the kernel-state receive queue to the user-mode data buffer when the number of multiple data packets is greater than the preset batch threshold, where the user state corresponds to the user process, the kernel The state corresponds to the protocol stack.

The embodiment of the present invention provides a server, and FIG. 5 is a schematic structural diagram of a server according to an embodiment of the present invention. As shown in FIG. 5, the server includes a protocol stack 52, and the protocol stack 52 includes the data packet processing apparatus provided by the foregoing embodiment. 522.

Hereinafter, the following description will be made in conjunction with the preferred embodiments, and the following preferred embodiments incorporate the above-described embodiments and preferred embodiments thereof. FIG. 6 is a flowchart of a method for processing a data packet according to a preferred embodiment of the present invention. The method is based on protocol stack layer processing. As shown in FIG. 6, the method includes the following steps: Step S602: Using jprobe's management method, batch receiving data pack. Using the kernel debugging mechanism provided by the Linux system, jprobe's management method inserts an increased batch receiving packet function into the receiving interface of the protocol stack. This function is used to receive data packets in batches. For example, suppose the server where the Linux system is located is streaming media. After the server receives the batch receiving packet function through jprobe, the streaming server receives the data packet from other media resource servers in batches. Of course, if the media resource is streaming media The server local, after calling the batch receive packet function, the streaming server will get multiple packets locally. Through the above method, it is not necessary to modify the kernel code of the Linux operating system, and the kernel processing flow can be flexibly increased, so that the processing becomes convenient and quick, and the influence is small. Preferably, step S602 may specifically include the following steps: A, registering a jprobe probe point, and replacing the instruction code of the detected function with the instruction code of int 3 when registering the probe point;

B, in the execution of the exception of int 3, call jprobe's exception handling function by means of a notification chain;

C, in jprobe's exception handler, determine whether there is a pre_handler hook function, where the hook function is equivalent to batch receiving packet functions. If there is a hook function, continue the hook function; D, after executing the hook function, prepare to enter the single-step debugging, and modify the address returned by the exception to the saved original by setting the trace flag (Trap Flag, TF for short) in the EFLAGS register. Instruction code

E, the code returns, the original instruction is executed, and the single step exception is triggered after the execution ends;

F, in the processing of the single-step exception, clear the single-step flag, execute the post-handler process, and finally return; Step S604, return multiple data packets. When the data packet received by the skb receiving queue in the kernel state reaches a predetermined batch threshold, the kernel buffer of the socket buffer (skb) receiving queue is copied to the data buffer of the user state in batches. Area. Through the above steps, the efficiency of receiving the data packet is improved, and the number of kernel state and user state switching is reduced to lj l/n, where n is the number of received data packets.

7 is a flow chart of a second method of data packet processing in accordance with a preferred embodiment of the present invention. In this embodiment, the server may include a user process, a Linux kernel space, and a hardware device. Between the hardware device and the user process is a Linux kernel space, and a hook function is added to the protocol stack receiving interface in the kernel space, that is, a batch receiving packet function, receiving a bulk data packet, and receiving a specified amount of data. After the packet, the packet is returned to the user mode in bulk. As shown in FIG. 7, the method includes the following steps: Step S702: A user process sends a bulk receiving data packet request to a protocol stack. The user process creates a socket socket using the standard protocol stack and receives the data packet using the standard receive receipt packet interface recvmsgO. The user process is specified in the msg_name of the struct msghdr collection structure. The number of received packets in batches, where the recvmsgO function is equivalent to receiving packets in batches, and the number of received packets received in batches is equivalent to a preset batch threshold. Step S704, the protocol stack receives the data packet in batches. The protocol stack inserts the judp_recvmsg collection and processing function through jprobe, receiving a batch of data packets each time. Among them, judp_recvmsg receiving packet processing function is equivalent to batch receiving packet function. Step S706, storing the received data packet in a receiving queue. The protocol stack stores the packets received in batches in the skb receive queue. Step S708, copying the data packet in the receiving queue to the data buffer in the user state. Call the n _e tif_ _reCV _skb function to copy the packets in the receive queue to the data buffer in the user mode. In this embodiment, each time the user state to the kernel mode switch can receive a batch of data packets, effectively reducing the overhead of the system call. From the above description, it can be seen that the embodiment of the present invention achieves the following technical effects: using the original Linux network protocol stack, the bulk data packet is received through the kernel debugging mechanism, so that the loading and unloading of the kernel module are not performed. Will affect the original network protocol stack of the Linux kernel. Obviously, those skilled in the art should understand that the above modules or steps of the present invention can be implemented by a general-purpose computing device, which can be concentrated on a single computing device or distributed among multiple computing devices. On the network, optionally, they may be implemented by program code executable by the computing device, such that they may be stored in the storage device by the computing device and, in some cases, may be different from The steps shown or described are performed sequentially, or they are separately fabricated into individual integrated circuit modules, or a plurality of modules or steps thereof are fabricated into a single integrated circuit module. Thus, the invention is not limited to any specific combination of hardware and software. The above is only the preferred embodiment of the present invention, and is not intended to limit the present invention, and various modifications and changes can be made to the present invention. Any modifications, equivalent substitutions, improvements, etc. made within the spirit and scope of the present invention are intended to be included within the scope of the present invention. Industrial Applicability As described above, a data packet processing method, apparatus, and server provided by an embodiment of the present invention have the following beneficial effects: Using the original Linux network protocol stack, the bulk data packet is received through the kernel debugging mechanism, thereby The kernel module loading and unloading will not affect the original network protocol stack of the Linux kernel.

Claims

A method for processing a data packet, comprising: a protocol stack responding to a request for receiving a data packet in batches, and receiving a plurality of data packets through a kernel debugging mechanism of an operating system;

After the number of the plurality of data packets is greater than a preset batch threshold, the plurality of data packets are returned.

2. The method of claim 1, wherein receiving the plurality of data packets by a kernel debugging mechanism of the operating system comprises: receiving the plurality of data packets by a jprobe mechanism provided by a kernel of the operating system.

3. The method of claim 2, wherein receiving the plurality of data packets by the jprobe mechanism provided by a kernel of the operating system comprises:

Using jprobe's management method, adding a batch receiving data packet function to the receiving interface of the protocol stack;

The batch receiving packet function is called to receive the plurality of data packets.

The method according to claim 3, wherein the request of the protocol stack to receive the data packet in batch includes: the protocol stack responding to a request of a user process for receiving a data packet in batches.

5. The method according to claim 4, wherein, after the number of the plurality of data packets is greater than the preset batch threshold, returning the plurality of data packets includes:

Determining whether the number of the plurality of data packets received in the receive queue of the kernel mode is greater than the preset batch threshold; if the number of the multiple data packets is greater than the preset batch threshold, The plurality of data packets in the receive queue of the kernel state are copied to the data buffer of the user state, wherein the user state corresponds to the user process, and the kernel state corresponds to the protocol stack.

A processing device for a data packet, located on a protocol stack, comprising: a control module, configured to receive a plurality of data packets through a kernel debugging mechanism of an operating system in response to a request for obtaining a data packet in batches;

Returning to the module, the method is configured to return the multiple data packets after the number of the multiple data packets is greater than a preset batch threshold. The apparatus according to claim 6, wherein the control module is further configured to receive the plurality of data packets by a jprobe mechanism provided by a kernel of the operating system. The device according to claim 7, wherein the control module comprises: a setting unit, configured to increase a batch receiving data packet function in a receiving interface of the protocol stack by using a jprobe management method;

The receiving unit is configured to invoke the batch receiving data packet function to receive the plurality of data packets. The apparatus of claim 6, wherein the control module is further configured to receive a request for a data packet in response to a batch of a user process. The apparatus according to claim 9, wherein the returning module comprises: a determining unit, configured to determine whether the number of the plurality of data packets received in a receiving queue of the kernel state is greater than the preset batch threshold;

a copy unit, configured to copy, in a case where the number of the plurality of data packets is greater than the preset batch threshold, to copy a plurality of data packets in the receive queue of the kernel state to a data buffer of a user state, where The user state corresponds to the user process, and the kernel state corresponds to the protocol stack.

A server comprising a protocol stack, the protocol stack comprising the apparatus of any one of claims 6 to 10.