Apparatus and method for extending a standard-based remote file access protocol and maintaining compatibility with the standard protocol stack. network file system (nfs) remote procedure calls (RPCs) that are submitted by an nfs client application are intercepted in a manner that is transparent to the client operating system. The intercepted nfs-RPCs are sent to a file interface card. The file interface card includes a processor that executes code that implements the standard nfs-RPC protocol, along with extensions to the standard nfs-RPC protocol. Non-nfs RPCs are sent to a conventional network interface card for processing.
|
1. A file interface arrangement for providing remote file access to a data processing system via a network, the data processing system including a first processor arrangement coupled to a system input/output bus, and a network interface card that is a first card coupled to the system input/output bus, wherein the first processor arrangement of the data processing system executes an operating system and a network file system (nfs) client application, the file interface arrangement comprising:
a file interface card that is a second card;
a bus-interface circuit disposed on the file interface card and arranged to interface with the system input/output bus;
a second processor arrangement disposed on the file interface card and coupled to the bus-interface circuit;
a memory disposed on the file interface card and coupled to the second processor arrangement, the memory configured with program code that is executable by the second processor arrangement and that implements a standard nfs client protocol, at least one non-standard extension to the nfs client protocol, and a network protocol stack;
an interceptor module executing on the first processor arrangement and coupled to the operating system and to the system bus, the interceptor module configured and arranged to intercept nfs-client remote procedure calls from the NES client application and send NES-client remote procedure calls to the second processor arrangement via the system bus and send remote procedure calls that are not nfs calls to the network interface card; and
a network-interface circuit arrangement disposed on the file interface card and coupled to the second processor arrangement and arranged to send data received from the second processor arrangement over the network and receive data via the network.
7. A data processing system, comprising:
a first processor configured to execute an operating system and an nfs client application;
a system input/output (I/O) bus coupled to the processor;
a network interface card coupled to the system I/O bus, the network interface card arranged to send data received from the first processor over a network and receive data via the network;
a file interface card coupled to the system I/O bus, wherein the file interface card implements a standard nfs client protocol responsive to the nfs client application executing on the first processor, at least one non-standard extension to the nfs client protocol, and a network protocol stack, and is adapted to send nfs requests over the network and receive nfs data via the network; and
wherein the file interface card includes,
a bus-interface circuit arranged to interface with the system input/output bus:
a second processor coupled to the bus-interface circuit:
a memory coupled to the processor arrangement, the memory configured with program code that is executable by the second processor and that implements the standard nfs client protocol, each non-standard extension to the NES client protocol, and the network protocol stack; and
a network-interface circuit arrangement coupled to the processor arrangement and arranged to send data received from the second processor over the network and receive data via the network;
wherein the file interface card and the network interface card have respective connections to the system I/O bus; and
an interceptor module coupled to the operating system and to the system bus, the interceptor module configured and arranged to intercept nfs-client calls from the nfs client application and send nfs-client calls to the second processor via the system bus.
2. The arrangement of
3. The interface arrangement of
4. The arrangement of
5. The interface arrangement of
6. The interface arrangement of
8. The system of
9. The system of
10. The system of
11. The system of
12. The system of
|
The present invention generally relates to standards-based protocols, and more particularly to an arrangement and method for extending a standard-based protocol while maintaining compatibility with standard-based protocol stack.
The Network File System (NFS) is a standard network protocol that makes files stored on a file server accessible to any computer (client) on a network. The NFS client protocol provides access to files that reside on the remote server, in the same way as a client's local file system provides access to files that are stored on a local disk. NFS is transparent to client applications and exposes a traditional file system interface.
The NFS client protocol makes Remote Procedure Calls (RPCs) to the remote server in order to implement access to the files. The interface is implemented by the NFS protocol using RPCs. The RPC layer also provides methods for data representation that are independent of the host architecture. For example, when a client application needs to write to a file that resides in a remote server, it calls a generic write ( ) system call. The NFS client protocol implements the write ( ) call by invoking a request to the remote server via the RPC layer. RPC marshals the data and parameters of the write ( ) call in to a message and encodes the latter in an architecture independent format. The message is sent to the remote host via the TCP/IP protocol stack. It is delivered up by the TCP/IP stack of the server to the RPC layer, where it is unpacked and passed to the NFS server protocol. The NFS server protocol implements the write ( ) operation by accessing the server's local file system. A reply is sent back to the client through the NFS, RPC and TCP/IP protocol layers.
The RPC layer uses standard external data representation (XDR) for the information exchanged between different computer architectures. NFS on a file server provides a transparent, stateless access to shared data.
Improving the performance of a standard protocol such as NFS will often involve deviating from or extending the standard. In order to implement such improvements, both the client-side NFS protocol and the server-side NFS protocol may require enhancements. This creates hurdles for both vendors and potential customers of improved systems. While a vendor of an improved NFS-based file server could wait and hope that its extensions to the standard are adopted, the time and effort involved in changing standards along with rapidly changing market conditions, may render this approach unworkable.
A system and method that address the aforementioned problems, as well as other related problems, are therefore desirable.
In various embodiments, an apparatus and method are provided for extending a standard-based protocol while and maintaining compatibility with the standard protocol stack. Network file system (NFS) remote procedure calls (RPCs) that are submitted by an NFS client application are intercepted in a manner that is transparent to the client operating system. The intercepted NFS-RPCs are sent to a file interface card. The file interface card includes a processor that executes code that implements the standard NFS-RPC protocol, along with extensions to the standard NFS-RPC protocol. Non-NFS RPCs are sent to a native (OS) communication protocol stack, and from the OS protocol stack the non-NFS RPCs are submitted to a conventional network interface card (NIC). The processor on the file interface card also provides TCP/IP, UDP and other protocol processing. Non-NFS RPCs are forwarded to a native protocol stack and are sent over a network via a conventional network interface card (NIC).
It will be appreciated that various other embodiments are set forth in the Detailed Description and Claims which follow.
Various aspects and advantages of the invention will become apparent upon review of the following detailed description and upon reference to the drawings in which:
In various embodiments of the invention, an NFS client proxy interacts with NFS servers having extensions to the standard NFS protocol, and other system entities such as storage area network (SAN) devices, name servers and other server systems. The NFS client proxy is implemented on the extended file interface card (EFIC), which also runs a complete network stack, including the TCP/UDP stack and IP layer. By implementing the proprietary portion of the protocol on the interface card, performance is enhanced and the proprietary interactions are hidden from the standard NFS software on the client system. With the present invention, extensions that seek to improve performance, scalability, and fault-tolerance of distributed file systems, for example can be implemented in a manner that minimizes adaptation of the client system.
Client system 102 includes a conventional processor 112 that is coupled to the extended file interface card (EFIC) 114 and a conventional network interface card 116 via the host I/O bus 118 (e.g., PCI bus). The NFS client proxy 110 is implemented on the EFIC 114, along with the standard TCP/UDP stack 118, IP layer 120, and physical layer 121. The NFS client proxy implements functional extensions added to the standard NFS protocol. Network interface card 116 provides a standard interface for client system 102 to the network 108. For example, network interface card 116 may be any one of a number of commercially available cards for connecting a Unix, Linux, NT, or Windows based machine to a network.
Processor 112 hosts software elements NFS client 122, interceptor module 124, EFIC interface 126, and native protocol stack 128. NFS client is an example client application that makes NFS-RPC calls. Interceptor module 124 is a software module that works in conjunction with EFIC 114. The function of interceptor module 124 is to intercept RPC calls, and depending on the particular procedure referenced, direct the call to either EFIC interface 126 or to native protocol stack 128 for processing. NFS-specific RPC calls are directed to EFIC interface 126, and other RPC calls are directed to native protocol stack 128. Two alternative implementations of interceptor module are described in
The upper layers of the standard NFS client protocol are implemented in the operating system kernel (not shown) of the client system. The upper layers of the NFS client protocol implement the generic file system operations, such as read ( ), write ( ), open( ), etc., and in some cases generate messages that are sent via the RPC layer. This functionality is implemented in the OS kernel and is not affected by interceptor module 124 or by the NFS client proxy 110.
The lower layers of the standard NFS client protocol, along with any extensions to the standard protocol, are implemented in the NFS client proxy element 110 on the EFIC 114. The lower layers include functionality that is related to the construction and transmission of NFS-specific RPC messages. For example, the lower layers control how the RPC messages (for NFS-read ( ), NFS-write ( ), etc.) are packed, encoded, and where the messages are sent over the TCP/IP stack. In different embodiments, the servers to which the RPC messages are sent and the interactions with the servers are extended in non-standard ways in the EFIC. For example, one RPC message submitted by the NFS client protocol may be interpreted and result in several other RPC and non-RPC messages being generated and sent to entities on the network such as meta-data servers, name servers, etc.
Server system 104 is an example data processing system that hosts extended, non-standard NFS protocol software 132. The extended NFS protocol software 132 interacts with NFS client proxy 110 in accordance with extended NFS protocols. The server system 104 also includes conventional TCP/IP stack 134 and physical layer 136 for interfacing with network 108.
By implementing the NFS-RPC services in the EFIC 114 instead of the operating system, legacy systems can be upgraded to take advantage of extensions to NFS by installation of the EFIC and accompanying interceptor module 124. The present invention also removes the burden of having to rebuild and reinstall the operating system kernel to upgrade the client system 102. Once the EFIC 114 is installed in the client system 102, further enhancements can be made to the client's NFS interface by downloading new software to the EFIC, rather than having to upgrade the client's operating system.
For messages referencing other RPCs (non-NFS related), RPC interceptor 152 lets the message flow through to the native RPC layer 154. RPC layer 154 communicates with native TCP/IP stack 156 to send and receive messages over network 108 via network interface card 116.
The embodiment of
Processor 204 is configured to interrogate the packet header information that is stored in memory 206 in accordance with one or more network protocol handling operations (e.g., firewall filtering, load balancing, and TPC/IP or RTP protocol handling operations). In addition, processor 204 is configured for protocol interactions as defined by the extensions to the NFS-RPC protocol.
System interface 208 includes, in one embodiment, a direct memory access (DMA) controller that is configured to arbitrate between EFIC 114, host memory (not shown, and other devices that perform DAM transfers over host I/O bus 118. Further details regarding an example implementation of EFIC 114 can be found in the application/patent entitled, “PROCESSING NETWORK PACKETS”, by Russell et al., filed on Aug. 11, 2000, having application/patent No. 09/630,033, and assigned to the assignee of the present invention. The contents of the application/patent are incorporated herein by reference.
At step 306, the message is sent to the NFS client proxy on the EFIC 114. The client proxy performs on behalf of the host processor 112 the client-related NFS operations, as well as any non-standard extensions to the NFS operations. Messages returned from the client proxy are returned to the client application at step 308 to complete the process.
For non-NFS related messages, decision step 304 directs the process to step 310. Non-NFS messages are forwarded to the native RPC over TCP/IP stack for standard processing. At step 312, messages returned from the native RPC stack are returned to the NFS client.
At step 356, the message is sent to the NFS client proxy on the EFIC 114. The client proxy performs on behalf of the host processor 112 the client-related NFS operations, as well as any non-standard extensions to the NFS operations. Messages returned from the client proxy are returned to the client application at step 358 to complete the process.
For non-NFS related RPC packets, decision step 354 directs the process to step 360. Non-NFS RPC packets are forwarded to the native TCP/IP stack for standard processing. At step 362, messages returned from the native TCP/IP stack are returned to the NFS client.
At step 402, the NFS client proxy receives a packet from the interceptor module 124. The function code is obtained from the NFS-RPC packet at step 404. The function code dictates the protocol by which the NFS client proxy will interact with the addressed server system. At step 406, the NFS client proxy performs the protocol processing dictated by the function code in the packet. For example, for standard NFS functions (functions that have not been extended), the NFS client proxy interacts with the server in a manner consistent with the standard. For extended NFS functions (non-standard), the NFS client proxy interacts with the server in the manner defined by the extended function.
When the NFS client proxy reaches a state in the interaction with the server system where the protocol specifies, the data or response is returned to the host processor, as shown by step 408. The client proxy repeats this general process for each NFS-RPC packet received from the host processor.
The present invention is believed to be applicable to a variety of computer system architectures and with a variety of operating systems. Other aspects and embodiments of the present invention will be apparent to those skilled in the art from consideration of the specification and practice of the invention disclosed herein. It is intended that the specification and illustrated embodiments be considered as examples only, with a true scope and spirit of the invention being indicated by the following claims.
Karamanolis, Christos, Zhang, Zheng, Mahalingam, Mallik
Patent | Priority | Assignee | Title |
10209922, | Aug 24 2011 | Rambus Inc. | Communication via a memory interface |
10846155, | Oct 16 2018 | Samsung Electronics Co., Ltd. | Method for NVMe SSD based storage service using RPC and gRPC tunneling over PCIe + |
11048410, | Aug 24 2011 | Rambus Inc | Distributed procedure execution and file systems on a memory interface |
11132328, | Dec 20 2013 | Rambus Inc | High level instructions with lower-level assembly code style primitives within a memory appliance for accessing memory |
11860813, | Dec 20 2013 | Rambus Inc. | High level instructions with lower-level assembly code style primitives within a memory appliance for accessing memory |
7606921, | Sep 21 2005 | SAP SE | Protocol lifecycle |
7711836, | Sep 21 2005 | SAP SE | Runtime execution of a reliable messaging protocol |
7716279, | Sep 21 2005 | SAP SE | WS addressing protocol for web services message processing runtime framework |
7716360, | Sep 21 2005 | SAP SE | Transport binding for a web services message processing runtime framework |
7721293, | Sep 21 2005 | SAP SE | Web services hibernation |
7761533, | Sep 21 2005 | SAP SE | Standard implementation container interface for runtime processing of web services messages |
7788338, | Sep 21 2005 | SAP SE | Web services message processing runtime framework |
8095628, | Oct 26 2009 | International Business Machines Corporation | Consolidated notifications to NFS clients |
8745252, | Sep 21 2005 | SAP AG | Headers protocol for use within a web services message processing runtime framework |
8914456, | Oct 26 2009 | International Business Machines Corporation | Consolidated notifications to NFS clients |
9043513, | Aug 24 2011 | Rambus Inc. | Methods and systems for mapping a peripheral function onto a legacy memory interface |
9098209, | Aug 24 2011 | Rambus Inc | Communication via a memory interface |
9275733, | Aug 24 2011 | Rambus Inc. | Methods and systems for mapping a peripheral function onto a legacy memory interface |
9665533, | Dec 20 2013 | Rambus Inc | Blob pools, selectors, and command set implemented within a memory appliance for accessing memory |
9690637, | Sep 21 2005 | SAP SE | Web services message processing runtime framework |
9880971, | Dec 20 2013 | Rambus Inc | Memory appliance for accessing memory |
9921751, | Aug 24 2011 | Rambus Inc. | Methods and systems for mapping a peripheral function onto a legacy memory interface |
9934194, | Dec 20 2013 | Rambus Inc | Memory packet, data structure and hierarchy within a memory appliance for accessing memory |
Patent | Priority | Assignee | Title |
5613155, | Jun 07 1995 | International Business Machines Corporation | Bundling client write requests in a server |
5619645, | Apr 07 1995 | Oracle America, Inc | System isolation and fast-fail |
5713017, | Jun 07 1995 | International Business Machines Corporation | Dual counter consistency control for fault tolerant network file servers |
5828876, | Jul 31 1996 | STEELEYE TECHNOLOGY, INC | File system for a clustered processing system |
6185615, | Feb 25 2000 | Oracle America, Inc | Method and system for consolidating related partial operations into a transaction log |
6212640, | Mar 25 1999 | Oracle America, Inc | Resources sharing on the internet via the HTTP |
6356863, | Sep 08 1998 | DAYLIGHT CHEMICAL INFORMATION SYSTEMS, INC | Virtual network file server |
6493768, | Jan 02 1996 | International Business Machines Corporation | Remote procedure interface with support for multiple versions |
6654794, | Mar 30 2000 | SNAPCHAT, INC | Method, data processing system and program product that provide an internet-compatible network file system driver |
6826613, | Mar 15 2000 | Hewlett Packard Enterprise Development LP | Virtually addressing storage devices through a switch |
20010032320, | |||
20020083111, |
Executed on | Assignor | Assignee | Conveyance | Frame | Reel | Doc |
Jan 29 2001 | KARAMANOLIS, CHRISTOS | Hewlett-Packard Company | ASSIGNMENT OF ASSIGNORS INTEREST SEE DOCUMENT FOR DETAILS | 011970 | /0351 | |
Jan 29 2001 | ZHANG, ZHENG | Hewlett-Packard Company | ASSIGNMENT OF ASSIGNORS INTEREST SEE DOCUMENT FOR DETAILS | 011970 | /0351 | |
Jan 29 2001 | MAHALINGAM, MALLIK | Hewlett-Packard Company | ASSIGNMENT OF ASSIGNORS INTEREST SEE DOCUMENT FOR DETAILS | 011970 | /0351 | |
Jan 31 2001 | Hewlett-Packard Development Company, L.P. | (assignment on the face of the patent) | / | |||
Sep 26 2003 | Hewlett-Packard Company | HEWLETT-PACKARD DEVELOPMENT COMPANY L P | ASSIGNMENT OF ASSIGNORS INTEREST SEE DOCUMENT FOR DETAILS | 014061 | /0492 |
Date | Maintenance Fee Events |
Jul 30 2010 | M1551: Payment of Maintenance Fee, 4th Year, Large Entity. |
Sep 12 2014 | REM: Maintenance Fee Reminder Mailed. |
Jan 30 2015 | EXP: Patent Expired for Failure to Pay Maintenance Fees. |
Date | Maintenance Schedule |
Jan 30 2010 | 4 years fee payment window open |
Jul 30 2010 | 6 months grace period start (w surcharge) |
Jan 30 2011 | patent expiry (for year 4) |
Jan 30 2013 | 2 years to revive unintentionally abandoned end. (for year 4) |
Jan 30 2014 | 8 years fee payment window open |
Jul 30 2014 | 6 months grace period start (w surcharge) |
Jan 30 2015 | patent expiry (for year 8) |
Jan 30 2017 | 2 years to revive unintentionally abandoned end. (for year 8) |
Jan 30 2018 | 12 years fee payment window open |
Jul 30 2018 | 6 months grace period start (w surcharge) |
Jan 30 2019 | patent expiry (for year 12) |
Jan 30 2021 | 2 years to revive unintentionally abandoned end. (for year 12) |