US8713180B2 - Zero-copy network and file offload for web and application servers - Google Patents

Zero-copy network and file offload for web and application servers Download PDF

Info

Publication number
US8713180B2
US8713180B2 US11/386,487 US38648706A US8713180B2 US 8713180 B2 US8713180 B2 US 8713180B2 US 38648706 A US38648706 A US 38648706A US 8713180 B2 US8713180 B2 US 8713180B2
Authority
US
United States
Prior art keywords
data
application server
running
operating systems
plurality
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Active, expires
Application number
US11/386,487
Other versions
US20060294234A1 (en
Inventor
Mark A. Bakke
Timothy J. Kuik
David P. Thompson
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Cisco Technology Inc
Original Assignee
Cisco Technology Inc
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Priority to US69313305P priority Critical
Application filed by Cisco Technology Inc filed Critical Cisco Technology Inc
Priority to US11/386,487 priority patent/US8713180B2/en
Assigned to CISCO TECHNOLOGY, INC. reassignment CISCO TECHNOLOGY, INC. ASSIGNMENT OF ASSIGNORS INTEREST (SEE DOCUMENT FOR DETAILS). Assignors: BAKKE, MARK A., KUIK, TIMOTHY J., THOMPSON, DAVID P.
Publication of US20060294234A1 publication Critical patent/US20060294234A1/en
Application granted granted Critical
Publication of US8713180B2 publication Critical patent/US8713180B2/en
Active legal-status Critical Current
Adjusted expiration legal-status Critical

Links

Images

Classifications

    • HELECTRICITY
    • H04ELECTRIC COMMUNICATION TECHNIQUE
    • H04LTRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
    • H04L69/00Application independent communication protocol aspects or techniques in packet data networks
    • H04L69/16Transmission control protocol/internet protocol [TCP/IP] or user datagram protocol [UDP]
    • HELECTRICITY
    • H04ELECTRIC COMMUNICATION TECHNIQUE
    • H04LTRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
    • H04L69/00Application independent communication protocol aspects or techniques in packet data networks
    • H04L69/16Transmission control protocol/internet protocol [TCP/IP] or user datagram protocol [UDP]
    • H04L69/161Implementation details of TCP/IP or UDP/IP stack architecture; Specification of modified or new header fields
    • HELECTRICITY
    • H04ELECTRIC COMMUNICATION TECHNIQUE
    • H04LTRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
    • H04L69/00Application independent communication protocol aspects or techniques in packet data networks
    • H04L69/16Transmission control protocol/internet protocol [TCP/IP] or user datagram protocol [UDP]
    • H04L69/161Implementation details of TCP/IP or UDP/IP stack architecture; Specification of modified or new header fields
    • H04L69/162Implementation details of TCP/IP or UDP/IP stack architecture; Specification of modified or new header fields involving adaptations of sockets based mechanisms
    • HELECTRICITY
    • H04ELECTRIC COMMUNICATION TECHNIQUE
    • H04LTRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
    • H04L69/00Application independent communication protocol aspects or techniques in packet data networks
    • H04L69/30Definitions, standards or architectural aspects of layered protocol stacks
    • H04L69/32High level architectural aspects of 7-layer open systems interconnection [OSI] type protocol stacks

Abstract

Methods and apparatus for transferring data from an application server are provided. By offloading network and file system stacks to a common stack accessible by multiple operating systems in a virtual computing system, embodiments of the present invention may achieve data transfer support for web and application servers without the data needing to be copied to or reside in the address space of the server operating systems.

Description

RELATED APPLICATIONS

The present invention claims benefit of provisional application Ser. No. 60/693,133, entitled “Network Stack Offloading Approaches” filed on Jun. 22, 2005, herein incorporated by reference in its entirety.

BACKGROUND OF THE INVENTION

1. Field of the Invention

The present invention generally relates to computer networks and, more particularly, to offloading network and file services.

2. Description of the Related Art

The primary task of web and application servers is typically to retrieve files from local file systems and send the file contents to remote clients, for example, over established Transmission Control Protocol (TCP) connections. In a typical application, a remote client connected to a server over a company Intranet or the Internet may request a file from a server. As an example, a web server may receive a request for a file (e.g., a document, image, HTML file, or the like) from a client connected via a TCP socket connection, retrieve the file, and send the file to the requester.

FIG. 1 illustrates such a file access involving a conventional server system. An operating system (e.g., Linux, Windows, or some other operating system) usually segregates the available system memory (and other resources) into user space 110 and kernel space 120. The kernel space is typically reserved for running the kernel, device drivers and any kernel extensions and includes file systems, network interface services, and the like. On the other hand, user space includes memory areas used by user applications. User applications cannot typically access the kernel space directly and, similarly, kernel code cannot access the user space without first checking whether the page is present in memory or swapped out.

As illustrated, when a request for a file is received by an application server 122, the application server 122 typically issues several read requests to copy data from the file system buffer cache 130 in kernel space 120 to buffers in user space 110. For example, in the kernel, the requested data may be first retrieved (e.g., from disk) and copied into the file system buffer cache 130 and then copied into memory the application server 122 can access, such as a buffer created by the application server 122 for this purpose and specified with the read request.

After copying the data into user space, the application server 122 sends the data back out to buffers 140 (e.g., TCP socket buffers) in kernel space 120. In this typical scenario, the application server 122 never needs to actually examine the data. Thus, copying the data from the file system buffer cache 130 to user space is inefficient, resulting in processing delays and consumption of resources (processing and memory resources) in user space 110.

In an effort to more efficiently transfer data, mechanisms, such as the Linux sendfile command, have been created that attempt to avoid inefficient copying of data to and from user space. Rather than copying read data from the file system buffer cache 130 into user space 110, only to send it back down, the application server 122 may issue a single sendfile command specifying a descriptor of a file from which data is to be read from (as well as a location within the file and number of bytes to read), and a descriptor of a socket on which the file will be sent. Because this transfer occurs within the kernel, a copy to and from user space of the application server may be avoided.

Unfortunately, this approach still consumes kernel resources, requiring copying data into the kernel file system buffer cache, writing out to socket buffers, and is less than optimal. As an example, in virtual machine systems running multiple operating system images, for security reasons, care must be taken to ensure each operating system image cannot access memory allocated by the other operating system images. As a result, copying data into kernel space (e.g., to process a sendfile command) typically entails mapping physical memory pages into the operating system image virtual address space. This mapping is typically a lengthy, processing intensive task involving access to operating system image page tables.

Therefore, what is needed is a more efficient mechanism for transferring data from a server, for example, that reduces the impact on local and kernel space resources.

SUMMARY OF THE INVENTION

Embodiments of the present invention provide methods and apparatus for transferring data from a server.

One embodiment provides a method for transferring data in response to a command issued from an application server. The method generally includes creating an offload stack structure running on one or more processor cores that may or may not be separate from one or more processor cores on which an operating system image executing the application server is running, the offload stack structure providing at least network and file stack resources, providing an interface to share network and file resources of the offload stack between multiple operating system images running on the multi-core system, and providing zero-copy data transfer support for the application server by processing the command issued from the application server to the offload stack without the need to copy data targeted by the command to address space of the operating system image on which the application server is running.

Another embodiment provides a host system generally including a plurality of processing cores, one or more operating system images running on one or more of the processing cores, an application server running on one of the operating system images, and an offload stack running on one or more processor cores separate from the one or more processor cores on which the operating system image running the application server is running. The offload stack structure generally provides zero-copy data transfer support for the application server by processing commands issued from the application server without the need to copy data targeted by the command to address space of the operating system image on which the application server is running.

Another embodiment provides a networked computing system generally including one or more host systems, each comprising one or more operating system images and an application server running on at least one of the operating system images, and a remote device coupled to the one or more host systems via a network connection and having an offload stack. The offload stack generally provides zero-copy data transfer support for the application server by processing commands issued from the application server without the need to copy data targeted by the command to address space of the operating system image on which the application server is running.

BRIEF DESCRIPTION OF THE DRAWINGS

So that the manner in which the above recited features of the present invention can be understood in detail, a more particular description of the invention, briefly summarized above, may be had by reference to embodiments, some of which are illustrated in the appended drawings. It is to be noted, however, that the appended drawings illustrate only typical embodiments of this invention and are therefore not to be considered limiting of its scope, for the invention may admit to other equally effective embodiments.

FIG. 1 illustrates an exemplary file access data path in conventional network systems in accordance with the prior art.

FIG. 2 illustrates a host utilizing an offload stack in accordance with one embodiment of the present invention.

FIG. 3 illustrates a detailed block diagram of an offload stack in accordance with one embodiment of the present invention.

FIG. 4 is a flow diagram of exemplary operations for transferring data utilizing an offload stack in accordance with embodiments of the present invention.

FIGS. 5A and 5B illustrate exemplary file access data paths utilizing an offload stack, in accordance with one embodiment of the present invention.

FIG. 6 illustrates an exemplary network system utilizing a remotely located offload stack, in accordance with one embodiment of the present invention.

DETAILED DESCRIPTION

By offloading network and file system stacks to a common stack accessible by multiple operating system images in a virtual computing system, embodiments of the present invention may achieve data transfer support for web and application servers without the data needing to be copied to or reside in the address space of the server operating system images. This “zero-copy” data transfer support may enable existing application servers to handle much larger volumes of traffic than conventional techniques without requiring significant modification to existing application server code.

To facilitate understanding, the following description will refer to a virtual computing environment in which multiple operating system images share one or more processor cores, possibly on the same central processing unit (CPU), as one type of application in which embodiments of the present invention may be used to advantage. However, those skilled in the art will recognize that embodiments of the present invention may be more generally applied in a variety of computing environments to achieve efficient data transfer by distancing the data path of requested data from the server receiving the request by offloading network and file services.

An Exemplary Common Offload Stack

FIG. 2 illustrates an exemplary host system 200, in which a plurality of operating systems (or OS images) 210 share a common offload stack 220. The common offload stack may operate as described in previously referenced provisional application Ser. No. 60/693,133, entitled “Network Stack Offloading Approaches” filed on Jun. 22, 2005. The host system 200 may include a number of resources, such as multiple processor cores and memory, shared between the operating systems 210. For example, each operating system 210 may be allocated some portion of shared memory and some portion or all processing bandwidth of one or more processor cores. Such a system is commonly referred to as a virtual system because, while the operating systems may share resources, they may operate independently, utilizing their allocated resources, as if each was operating in a separate computer system.

The growth of communications between devices (up to and beyond 1 Gbps) has led to rapidly increasing burdens on central processors (CPU), to implement communication processing (TCP/IP) functions. Servers utilizing multiple processors (or single CPUs with multiple processor cores) have been designed in an effort to achieve sufficient processor cycles to service application requirements and management of the communications stack, whether TCP/IP, any other type of interfaces, including peripheral stacks such as Fibre Channel, Infiniband, Firewire (IEEE 1394), USB, Bluetooth, and wireless 802.11. Along with increases in bandwidth, security requirements for inspecting traffic flows and protection are becoming more stringent and place a correspondingly higher burden on the CPU. Security issues are even more of a challenge in platforms with multiple operating systems, when one operating system seeks to modify space shared with another.

A variety of security functions rely on communications stacks, such as virtual private network VPN (functions), antivirus, inline encryption and message integrity, discovery, and identity protocols. Each of these functions requires management, especially where they cross operating system boundaries, resulting in a corresponding increase in CPU burden. For some embodiments of the present invention, however, the common offload stack 220 may offer a unified user interface that provides a mechanism for operating systems to offload security and related network management functions. By utilizing virtualization, the common offload stack 220 may provide a flexible open platform for network and I/O control functions acting, in some cases, as an integrated router between multiple operating systems 210 of the host system 200. In some cases, the offload stack may even run on a remote system (as described in further detail below, with reference to FIG. 6).

For some embodiments, the offload stack 220 may run on a separate core of a multi-core processor or, for some cases, even on a separate processor or offload card (as will be described in greater detail below with reference to FIG. 5B). The offload stack 220 may control all network and block storage interfaces, and can be shared between the multiple guest operating systems 210. In order to communicate with the offload stack 220, each operating system 210 may include a common stack interface front end (CSI F/E) 212, for example, implemented as a set of kernel drivers. The CSI F/E 212 may allow applications running in the operating systems 210 to communicate with network, block I/O, and file interfaces 221, 222, and 223, respectively, of the offload stack 220.

FIG. 3 illustrates the types of network, block I/O, and file functions that may be offloaded to the offload stack 220, and available to the operating systems 210 via the CSI F/E 212, according to one embodiment of the present invention. As illustrated, the network offload functions may include any type of appropriate network processing functions, such as RDMA 316, TCP 318, IP 320, and/or any other type of network functions 322, such as Ethernet, Infiniband, and/or wireless protocols (e.g., 802.11). By providing access to the offload stack via a socket interface, existing applications will not require changes to take advantage of offloading these functions.

As illustrated, the offload stack 220 may also provide file and block I/O functions, via file interface 223 and block I/O interface 222, respectively. The file system types may include the common Internet file system (CIFS) 302, the network file system (NFS) 304, an object file system 306 (e.g., Lustre), cluster type file system 308 (e.g., GFS), and a local file system 310. The CSI FE may be configured such that the file interface 223 is accessible under a virtual file system VFS (virtual file system) of the host 210.

The block I/O interface 222 may provide functional support for standard storage interfaces. For example, a small computer system interface (SCSI) support 312 may allow connection of SCSI (or iSCSI) storage devices, while a Fibre channel protocol (FCP) support 314 may allow connection of a storage device via a Fibre Channel interface 324.

In essence, the offload stack 220 appears to the operating systems 210 as being on the network. As a result, the network, file, and I/O functionality allow the offload stack 220 to function, in effect, as an intermediate embedded network device capable of bridging, switching or even routing between hosts on the server, and off the server when operating in conjunction with other (external) network devices deeper in a network.

Zero-Copy File Transfers Using an Offload Stack

As previously described, when transferring files requested from application servers using conventional network communications, a high cost is incurred to copy data between kernel buffers and user process virtual memory at the socket layer. However, by offloading network and file system stacks (both network and local file system) in the same common offload stack, embodiments of the present invention may be able to achieve “zero-copy” support for web and application servers by avoiding the need for data to be copied or even reside in the host address space. As a result, servers utilizing this approach may be able to handle significantly larger volumes of traffic than when utilizing conventional approaches and, in some cases, without significant modification to server application code.

FIG. 4 is a flow diagram of exemplary operations 400 for performing zero-copy data transfer in accordance with embodiments of the present invention, utilizing an offload stack. The operations begin, at step 402, by creating an offload stack running on a separate core of a multi-core machine. As described above, depending on the embodiment, the offload stack may be running on a separate dedicated physical core, multiple physical cores, or a virtual core allocated some portion of one or more physical cores.

At step 404, an interface to share the offload stack between multiple guest operating systems is provided. At step 406, zero-copy data transfer support for an application server running on a guest operating system is provided. Referring back to FIG. 2, the shared interface may include a combined interface including access to offloaded network services (via interface 221), block I/O services (via interface 222), and file services (via 223). The guest operating systems may access the services via a set of drivers, such as common shared interface (CSI) front end code also shown in FIG. 2. By offloading both the network and file system stacks (both network and local file system) in the same offload engine, the zero-copy data transfer support may avoid the need for targeted data to be copied to or reside in the guest operating address space. As a result, an application server may be able to handle much larger volumes of traffic, without significant modification.

FIG. 5A illustrates how an offload stack 550 may allow a data path of data transferred by an application server 522 to be removed from the address space of the operating system running the application server. In other words, the offload stack 550 may allow the application server 522 to transfer data without copying the data to user space 510 or kernel space 520, by sending a command (e.g., a sendfile command) specifying a source from which to read (e.g., a file or socket) and a write destination (e.g., a socket). In response to the command, the offload stack 550 in accordance with one embodiment of the present invention, may retrieve data from the specified source (e.g., into a file system buffer cache 530) and send the data directly to the specified write destination (e.g., to a socket connection via TCP socket buffers 540).

For some embodiments, a command issued by the application server 522 to achieve zero-copy support, may include a variety of arguments to specify what data to transfer and to where. For example, a sendfile command issued by the application server 522 and compatible with the offload stack may include arguments for specifying a descriptor of a file to read from (in_fd), a file to write to or stream socket on which the data will be sent on (out_fd). The command may optionally include a pointer to an offset field which specifies an offset location in a specified file to begin reading from (*offset), as well as a number of bytes to read/send (count). For some embodiments, to provide indication of successful completion of the command, the location of the byte immediately following the last byte sent from the file may be written to *offset.

To enable complete offload of the sendfile command, the out_fd may be converted to an offload stack specific file or socket identifier and the in_fd may be converted to an offload stack file identifier before sending the sendfile command over to the offload stack. The offload stack may then perform the complete I/O transaction on the offload processor(s), whether real or virtual. When the transaction has completed, status may be returned to the guest domain (including the value to be written to *offset) so that the originating sendfile( ) call can return appropriate status to the calling user application.

As illustrated in FIG. 5B, for some embodiments, the transfer data path may be moved even farther from the application server issuing the sendfile command, by offloading the offload stack 550 to a separate data path processor 560. Depending on the particular embodiment, the data path processor 560 may be a completely separate processor and may even be running on a separate “offload engine” interface card.

For some embodiments, the transfer data path may be even further removed from application servers issuing sendfile commands. For example, as illustrated in FIG. 6, a “remote” offload stack 650 may be offloaded to a separate processor on a remote device 680 with a network connection to hosts 600 running the application servers. As illustrated, for some embodiments, “local” offload stacks 620 may handle local devices and functions, passing shared network, block, and file service requests directly to the offload stack 650 located on the remote device 680.

In the illustrated arrangement, network and file services may be offloaded to the remote offload stack 650 on a network device, such as a gateway. In such cases, network, block and I/O interfaces may be passed directly over whatever type of medium is used for the network connection 692, such as Infiniband or a DataCenter Ethernet, and the gateway device 680 may include a compatible switch 690. Such an offload stack 650 on a network gateway may handle shared network, file, and I/O services for an entire cluster of server hosts 600. As a result, an application server on a host 600 may be able to transfer data via a zero-copy sendfile command, even if the data only exists in the remote offload stack 650.

Conclusion

Embodiments of the present invention may achieve data transfer support for web and application servers without the data needing to be copied to or reside in the address space of the server operating systems. This “zero-copy” data transfer support may be achieved by offloading network and file system stacks to a common stack accessible by multiple operating systems in a virtual computing system and may enable an application server to handle larger volumes of traffic than achievable using conventional techniques requiring data to be copied into address space of the operating system running the application server.

While the foregoing is directed to embodiments of the present invention, other and further embodiments of the invention may be devised without departing from the basic scope thereof, and the scope thereof is determined by the claims that follow.

Claims (24)

What is claimed is:
1. A computer-implemented method to transfer data via a buffer cache and in response to a command issued from a first application server, the command issued responsive to a request from a first client, the method comprising:
creating an offload stack running on a multiprocessing host having the buffer cache and on which a plurality of operating systems is running, wherein the plurality of operating systems includes a first operating system executing the first application server, wherein the offload stack is configured to provide a set of resources to one or more applications executing on the plurality of operating systems, the set of resources including network, file, and block I/O resources;
providing an interface to share the set of resources of the offload stack among the plurality of operating systems running on the multiprocessing host; and
providing zero-copy data transfer support for the first application server by processing the command issued from the first application server to the offload stack, in order to transfer data targeted by the command, to the first client, via the buffer cache of the multiprocessing host and not via any address space of the first operating system on which the first application server is running, wherein the command specifies a source of the data to transfer, a destination to transfer the data to, and an offset to start reading the data from.
2. The method of claim 1, wherein the command includes at least a source argument to specify the source of the data to be transferred and a destination argument to specify the destination to which the data is to be transferred.
3. The method of claim 1, wherein the interface to share the set of resources of the offload stack among the plurality of operating systems running on the multiprocessing host comprises driver code executable by the plurality of operating systems.
4. The method of claim 1, wherein the offload stack is created on a data path processor separate from any computer processor on which any of the plurality of operating systems are running.
5. A host system to transfer data via a buffer cache and in response to a command issued from a first application server, the command issued responsive to a request from a first client, the host system comprising:
one or more processing cores;
the buffer cache;
multiple operating systems running on at least one of the one or more processing cores;
a first application server running on a first operating system of the multiple operating systems;
an offload stack running on at least one of the one or more processing cores, the offload stack providing zero-copy data transfer support for the first application server by processing the command issued from the first application server, in order to transfer data targeted by the command, to the first client, via the buffer cache of the host system and not via any address space of the first operating system on which the first application server is running, wherein the offload stack is configured to provide a set of resources to one or more applications executing on the plurality of operating systems, the set of resources including network, file, and block I/O resources, wherein the command specifies a source of the data to transfer, a destination to transfer the data to, and an offset to start reading the data from; and
an interface to share the set of resources of the offload stack between the multiple operating systems.
6. The host system of claim 5, wherein the host system includes a plurality of processing cores including the one or more processing cores, wherein the first application server and the offload stack are running on different processing cores.
7. The host system of claim 5, wherein the command includes at least a source argument to specify the source of the data to be transferred and a destination argument to specify the destination to which the data is to be transferred.
8. The host system of claim 5, wherein the offload stack runs on a data path processing core separate from any processing core on which any of the multiple operating systems are running.
9. A system to transfer data via a buffer cache and in response to a command issued from a first application server, the command issued responsive to a request from a first client, the system comprising:
one or more computer processors;
a buffer cache;
a memory containing a program which, when executed by the one or more computer processors, performs an operation comprising:
creating an offload stack running on the system, on which system a plurality of operating systems is running, the plurality of operating systems including a first operating system executing the first application server, wherein the offload stack is configured to provide a set of resources to one or more applications executing on the plurality of operating systems, the set of resources including network, file, and block I/O resources;
providing an interface to share the set of resources of the offload stack among the plurality of operating systems running on the system; and
providing zero-copy data transfer support for the first application server by processing the command issued from the first application server to the offload stack, in order to transfer data targeted by the command, to the first client, via the buffer cache of the system and not via any address space of the first operating system on which the first application server is running, wherein the command specifies a source of the data to transfer, a destination to transfer the data to, and an offset to start reading the data from.
10. The system of claim 9, wherein the command includes at least a source argument to specify the source of the data to be transferred and a destination argument to specify the destination to which the data is to be transferred.
11. The system of claim 10, wherein the interface to share the set of resources of the offload stack among the plurality of operating systems running on the system comprises driver code executable by the plurality of operating systems.
12. The system of claim 11, wherein the offload stack is created on a data path processor separate from any computer processor on which any of the plurality of operating systems are running.
13. A non-transitory computer-readable medium containing program code which, when executed, performs an operation to transfer data via a buffer cache and in response to a command issued from a first application server, the command issued responsive to a request from a first client, the operation comprising:
creating an offload stack running on a multiprocessing host having the buffer cache and on which a plurality of operating systems is running, wherein the plurality of operating systems includes a first operating system executing the first application server, wherein the offload stack is configured to provide a set of resources to one or more applications executing on the plurality of operating systems, the set of resources including network, file, and block I/O resources;
providing an interface to share the set of resources of the offload stack among the plurality of operating systems running on the multiprocessing host; and
providing zero-copy data transfer support for the first application server by processing the command issued from the first application server to the offload stack, in order to transfer data targeted by the command, to the first client, via the buffer cache of the multiprocessing host and not via any address space of the first operating system on which the first application server is running, wherein the command specifies a source of the data to transfer, a destination to transfer the data to, and an offset to start reading the data from.
14. The non-transitory computer-readable medium of claim 13, wherein the offload stack is created on a data path processor separate from any computer processor on which any of the plurality of operating systems are running.
15. The method of claim 1, wherein the interface to share the set of resources of the offload stack between the multiple operating systems running on the multiprocessing host comprises driver code executable by the plurality of operating systems.
16. The method of claim 15, wherein the offload stack is created on a data path processing element separate from any processing element on which any of the multiple operating systems are running, wherein each processing element is selected from a computer processor and a processing core.
17. The method of claim 16, wherein the command issued from the first application server is issued responsive to the first application server receiving the request from the first client, wherein the first client comprises a remote client of the first application server.
18. The method of claim 17, wherein the method further comprises: providing zero-copy data transfer support for a second application server by processing a command issued from the second application server to the offload stack, in order to transfer data targeted by the command, to a second client, via the buffer cache of the multiprocessing host and not via any address space of a second operating system on which the second application server is running.
19. The method of claim 18, wherein the second operating system is different from the first operating system, wherein the second application is different from the first application, wherein the second client is different from the first client, wherein the command issued from the second application server is issued responsive to the second application server receiving a request from the second client, wherein the second client comprises a remote client of the second application.
20. The method of claim 19, wherein the first operating system and the second operating system are of different operating system types, wherein the first application and the second application are of different application types, wherein the offload stack does not occupy any address space of the first operating system.
21. The method of claim 20, wherein the data is transferred without copying the data from the buffer cache to any kernel address space of the first operating system, without copying the data from any kernel address space of the first operating system to any user address space of the first operating system, and without copying the data from any user address space of the first operating system to any socket buffer of the first operating system.
22. The method of claim 21, wherein the multiprocessing host consists of a single host system, wherein the multiprocessing host includes a plurality of processing elements, wherein the offload stack runs solely on a first processing element of the plurality of processing elements, wherein the first operating system runs solely on a second processing element of the plurality of processors elements, wherein the first processing element is different from the second processing element.
23. The method of claim 22, wherein the data targeted by the command is transferred to the first client using a socket connection via a socket buffer of the multi-core host, wherein the socket buffer is different from the buffer cache, wherein the socket buffer comprises a TCP socket buffer.
24. The method of claim 23, wherein the buffer cache does not occupy any address space of the first operating system, wherein the buffer cache does not occupy any address space of the second operating system, wherein the socket buffer does not occupy any address space of the first operating system, wherein the socket buffer does not occupy any address space of the second operating system.
US11/386,487 2005-06-22 2006-03-22 Zero-copy network and file offload for web and application servers Active 2030-10-12 US8713180B2 (en)

Priority Applications (2)

Application Number Priority Date Filing Date Title
US69313305P true 2005-06-22 2005-06-22
US11/386,487 US8713180B2 (en) 2005-06-22 2006-03-22 Zero-copy network and file offload for web and application servers

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
US11/386,487 US8713180B2 (en) 2005-06-22 2006-03-22 Zero-copy network and file offload for web and application servers

Publications (2)

Publication Number Publication Date
US20060294234A1 US20060294234A1 (en) 2006-12-28
US8713180B2 true US8713180B2 (en) 2014-04-29

Family

ID=39391383

Family Applications (1)

Application Number Title Priority Date Filing Date
US11/386,487 Active 2030-10-12 US8713180B2 (en) 2005-06-22 2006-03-22 Zero-copy network and file offload for web and application servers

Country Status (2)

Country Link
US (1) US8713180B2 (en)
CN (1) CN100573459C (en)

Cited By (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20160275042A1 (en) * 2015-03-17 2016-09-22 Arun Pathak Zero-copy data transmission system
US9563361B1 (en) 2015-11-12 2017-02-07 International Business Machines Corporation Zero copy support by the virtual memory manager
US10616076B2 (en) 2017-05-30 2020-04-07 International Business Machines Corporation Network asset management

Families Citing this family (36)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US7441112B2 (en) 2005-06-30 2008-10-21 Intel Corporation Offloading the processing of a network protocol stack
US7721299B2 (en) * 2005-08-05 2010-05-18 Red Hat, Inc. Zero-copy network I/O for virtual hosts
CN101005649A (en) * 2006-01-19 2007-07-25 华为技术有限公司 Connecting and establishing method and system for multiple communication traffic
US7610481B2 (en) 2006-04-19 2009-10-27 Intel Corporation Method and apparatus to support independent systems in partitions of a processing system
US7817634B2 (en) * 2006-06-30 2010-10-19 Intel Corporation Network with a constrained usage model supporting remote direct memory access
US8874780B2 (en) * 2006-07-17 2014-10-28 Qualcomm Incorporated Data buffering and notification system and methods thereof
WO2009011695A1 (en) * 2006-07-17 2009-01-22 Bigfoot Networks, Inc. Data buffering and notification system and methods thereof
US8819242B2 (en) * 2006-08-31 2014-08-26 Cisco Technology, Inc. Method and system to transfer data utilizing cut-through sockets
US20080155051A1 (en) * 2006-12-23 2008-06-26 Simpletech, Inc. Direct file transfer system and method for a computer network
US20080155050A1 (en) * 2006-12-23 2008-06-26 Simpletech, Inc. Direct file transfer host processor
US20080155049A1 (en) * 2006-12-23 2008-06-26 Simpletech, Inc. Direct file transfer communication processor
US8078674B2 (en) * 2007-05-10 2011-12-13 International Business Machines Corporation Server device operating in response to received request
US8543998B2 (en) 2008-05-30 2013-09-24 Oracle International Corporation System and method for building virtual appliances using a repository metadata server and a dependency resolution service
US8862633B2 (en) 2008-05-30 2014-10-14 Novell, Inc. System and method for efficiently building virtual appliances in a hosted environment
US8893160B2 (en) * 2008-06-09 2014-11-18 International Business Machines Corporation Block storage interface for virtual memory
US8472482B2 (en) * 2008-10-27 2013-06-25 Cisco Technology, Inc. Multiple infiniband ports within a higher data rate port using multiplexing
US9454368B2 (en) * 2009-01-21 2016-09-27 Vmware, Inc. Data mover permitting data transfer without transferring data between application and operating system
US9134922B2 (en) 2009-03-12 2015-09-15 Vmware, Inc. System and method for allocating datastores for virtual machines
US9092149B2 (en) 2010-11-03 2015-07-28 Microsoft Technology Licensing, Llc Virtualization and offload reads and writes
US9092426B1 (en) 2011-01-03 2015-07-28 Applied Micro Circuts Corporation Zero-copy direct memory access (DMA) network-attached storage (NAS) file system block writing
US9146765B2 (en) 2011-03-11 2015-09-29 Microsoft Technology Licensing, Llc Virtual disk storage techniques
JP5720324B2 (en) * 2011-03-11 2015-05-20 日本電気株式会社 Thin client environment providing system, server, thin client environment management method, and thin client environment management program
US8688799B2 (en) 2011-06-30 2014-04-01 Nokia Corporation Methods, apparatuses and computer program products for reducing memory copy overhead by indicating a location of requested data for direct access
US8595460B2 (en) 2011-08-26 2013-11-26 Vmware, Inc. Configuring object storage system for input/output operations
US9817582B2 (en) 2012-01-09 2017-11-14 Microsoft Technology Licensing, Llc Offload read and write offload provider
CN103369016A (en) * 2012-04-11 2013-10-23 长春易申软件有限公司 Method for realizing network storage protocol stack based on iSCSI
US10031782B2 (en) * 2012-06-26 2018-07-24 Juniper Networks, Inc. Distributed processing of network device tasks
US9612877B1 (en) 2012-07-12 2017-04-04 Cisco Technology, Inc. High performance computing in a virtualized environment
US9071585B2 (en) 2012-12-12 2015-06-30 Microsoft Technology Licensing, Llc Copy offload for disparate offload providers
US9251201B2 (en) 2012-12-14 2016-02-02 Microsoft Technology Licensing, Llc Compatibly extending offload token size
US9811319B2 (en) 2013-01-04 2017-11-07 Microsoft Technology Licensing, Llc Software interface for a hardware device
US20140195834A1 (en) * 2013-01-04 2014-07-10 Microsoft Corporation High throughput low latency user mode drivers implemented in managed code
US9313133B2 (en) * 2013-09-10 2016-04-12 Robin Systems, Inc. Anticipatory warm-up of cluster resources for jobs processed on multiple cluster nodes
US9772876B2 (en) * 2014-01-06 2017-09-26 International Business Machines Corporation Executing an all-to-allv operation on a parallel computer that includes a plurality of compute nodes
JP6265158B2 (en) * 2015-03-27 2018-01-24 横河電機株式会社 Electronics
CN107179878A (en) * 2016-03-11 2017-09-19 伊姆西公司 The method and apparatus of data storage based on optimizing application

Citations (6)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20030046330A1 (en) * 2001-09-04 2003-03-06 Hayes John W. Selective offloading of protocol processing
US6544295B1 (en) * 1996-11-18 2003-04-08 Starfish Software, Inc. Methods for managing preferred internet sites in a computer system having a browser
US20050039180A1 (en) * 2003-08-11 2005-02-17 Scalemp Inc. Cluster-based operating system-agnostic virtual computing system
US20060104295A1 (en) * 2004-11-16 2006-05-18 Secure64 Software Corporation Queued, asynchronous communication architecture interface
US7424710B1 (en) * 2002-12-18 2008-09-09 Vmware, Inc. TCP/IP offloading for virtual machines
US7502884B1 (en) * 2004-07-22 2009-03-10 Xsigo Systems Resource virtualization switch

Patent Citations (6)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6544295B1 (en) * 1996-11-18 2003-04-08 Starfish Software, Inc. Methods for managing preferred internet sites in a computer system having a browser
US20030046330A1 (en) * 2001-09-04 2003-03-06 Hayes John W. Selective offloading of protocol processing
US7424710B1 (en) * 2002-12-18 2008-09-09 Vmware, Inc. TCP/IP offloading for virtual machines
US20050039180A1 (en) * 2003-08-11 2005-02-17 Scalemp Inc. Cluster-based operating system-agnostic virtual computing system
US7502884B1 (en) * 2004-07-22 2009-03-10 Xsigo Systems Resource virtualization switch
US20060104295A1 (en) * 2004-11-16 2006-05-18 Secure64 Software Corporation Queued, asynchronous communication architecture interface

Cited By (7)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20160275042A1 (en) * 2015-03-17 2016-09-22 Arun Pathak Zero-copy data transmission system
US9584628B2 (en) * 2015-03-17 2017-02-28 Freescale Semiconductor, Inc. Zero-copy data transmission system
US9563361B1 (en) 2015-11-12 2017-02-07 International Business Machines Corporation Zero copy support by the virtual memory manager
US9740424B2 (en) 2015-11-12 2017-08-22 International Business Machines Corporation Zero copy support by the virtual memory manager
US9747031B2 (en) 2015-11-12 2017-08-29 International Business Machines Corporation Zero copy support by the virtual memory manager
US9971550B2 (en) 2015-11-12 2018-05-15 International Business Machines Corporation Zero copy support by the virtual memory manager
US10616076B2 (en) 2017-05-30 2020-04-07 International Business Machines Corporation Network asset management

Also Published As

Publication number Publication date
US20060294234A1 (en) 2006-12-28
CN100573459C (en) 2009-12-23
CN101171573A (en) 2008-04-30

Similar Documents

Publication Publication Date Title
US20180227248A1 (en) Remote shared server peripherals over an ethernet network for resource virtualization
US9729664B2 (en) System and method for managing connections between a client and a server
US10044622B2 (en) Load balancing for a virtual networking system
US9311001B1 (en) System and method for managing provisioning of storage resources in a network with virtualization of resources in such a network
US10635316B2 (en) Methods and systems for data storage using solid state drives
US9794196B2 (en) Application-controlled network packet classification
US10042561B2 (en) Distributed file serving architecture system with metadata storage virtualization and data access at the data server connection speed
US10445156B2 (en) Reception according to a data transfer protocol of data directed to any of a plurality of destination entities
US9448957B2 (en) Unified system area network and switch
US20180054485A1 (en) Methods, systems and devices for parallel network interface data structures with differential data storage and processing service capabilities
US9361042B2 (en) Accelerating internet small computer system interface (iSCSI) proxy input/output (I/O)
US8489778B2 (en) Method and apparatus for using a single multi-function adapter with different operating systems
US9390055B2 (en) Systems, methods and devices for integrating end-host and network resources in distributed memory
US20150254088A1 (en) Methods and systems for converged networking and storage
Islam et al. High performance RDMA-based design of HDFS over InfiniBand
US10248334B2 (en) Virtual storage target offload techniques
US20140229946A1 (en) Zero-copy network i/o for virtual hosts
Peter et al. Arrakis: The operating system is the control plane
US9037640B2 (en) Processing STREAMS messages over a system area network
US8984140B2 (en) Managing connections through an aggregation of network resources providing offloaded connections between applications over a network
US7979548B2 (en) Hardware enforcement of logical partitioning of a channel adapter's resources in a system area network
US9112752B2 (en) Network interface and protocol
US20140304359A1 (en) System and method for specifying batch execution ordering of requests in a storage system cluster
US7458075B2 (en) Virtual USB port system and method
US5991797A (en) Method for directing I/O transactions between an I/O device and a memory

Legal Events

Date Code Title Description
AS Assignment

Owner name: CISCO TECHNOLOGY, INC., CALIFORNIA

Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:BAKKE, MARK A.;KUIK, TIMOTHY J.;THOMPSON, DAVID P.;REEL/FRAME:017691/0322

Effective date: 20060321

STCF Information on status: patent grant

Free format text: PATENTED CASE

MAFP Maintenance fee payment

Free format text: PAYMENT OF MAINTENANCE FEE, 4TH YEAR, LARGE ENTITY (ORIGINAL EVENT CODE: M1551)

Year of fee payment: 4