r
`
`D 75 -} l-/~e;,iJ
`
`PROVISIONAL APPLICATION FOR PATENT
`COVERSHEET
`
`Case No. 3W ARE.OU PR
`Date: August 11, 2000
`Page 1
`
`e ==
`"°'""1::t"==
`·'° ==c
`m"° -o
`- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ::,c-.;a =...;
`.""1::t"-'
`.... ~-~
`r--\.0 ==o
`.-i ~ ~CX)
`u ~
`I":, ~
`
`ASSISTANT COMMISSIONER FOR PATENTS
`WASHINGTON, D.C. 20231
`
`ATTENTION: PROVISIONAL PATENT APPLICATION
`
`Sir:
`
`This is a request for filing a PROVISIONAL APPLICATION FOR PATENT under 37 CFR § l.53(c).
`
`For:
`
`ARCIDTECTURE FOR PROVIDING BLOCK-LEVEL STORAGE ACCESS OVER
`SOCKET CONNECTIONS
`
`Name of First Inventor:
`Residence Address:
`
`Douglas E. Jewett
`2503 Resnick Drive, Round Rock, Texas 78681
`
`Name of Second Inventor:
`Residence Address:
`
`Robert W. Horst
`12386 Larchmont Avenue, Saratoga, California 95070
`
`Name of Third Inventor:
`Residence Address:
`
`Bryan T. Silbermann
`13534 Myren Drive, Saratoga, California 95070
`
`Enclosed are the following:
`
`(X)
`
`(X)
`
`Specification in 21 pages;
`
`6 sheets of drawings;
`
`(X)
`
`A check in the amount of $150 to cover the filing fee; and
`
`(X)
`
`A return prepaid postcard.
`
`The Commissioner is hereby authorized to charge any additional fees which may be required, now or in
`the future, or credit any overpayment to Account No. 11-1410. A duplicate copy of this sheet is
`enclosed.
`
`Was this invention made by an agency of the United States Government or under a contract with an
`agency of the United States Government?
`
`(X)
`
`No.
`
`( )
`
`Yes. The name of the U.S. Government agency and the Government contract number
`are:
`
`620 NEWPORT
`
`KNOBBE,
`DP
`
`LLP
`
`Petitioners Microsoft Corporation and HP Inc. - Ex. 1030, p. i
`
`

`

`PROVISIONAL APPLICATION FOR PATENT
`COVERSHEET
`
`Case No. 3WARE.011PR
`Date: August 11, 2000
`Page2
`
`(X)
`
`Please send correspondence to:
`
`Ronald J. Schoenbaum
`Knobbe, Martens, Olson & Bear, LLP
`620 Newport Center Dr., 16th Floor
`Newport Beach, CA 92660
`
`Respectfully submitted,
`
`.~.~~
`
`RomtldJ.SchoenbaunV
`Registration No. 38,297
`
`H:\DOCS\ROS\ROS-2359.DOC\dns
`081100
`
`620 NE',VrORT
`
`Kt>.()R8E, MART
`DR
`
`Mt:Wc::>ORT OC~CH, CA -;;2cGo
`r:·1,x (~149) 1-:c-s,so2
`
`Petitioners Microsoft Corporation and HP Inc. - Ex. 1030, p. ii
`
`

`

`lf'iTEL'._EC"'."U/\l. Pr?OF·'2.PTY
`
`.__.1\W
`
`KNOBBE, MARTENS, OLSON & BEAR
`
`LOUIS J. v.~:ootlt. 'j
`[JON W. 1-/id'TENS ..
`G()RCOt- H. DI .. SON•
`J,\M;;:S 3.
`t3E,q~
`C•!IRPEL_ I •. OLSON"
`WI!...\. :AM R. RUN!s:FR
`WILL AM II.
`tJl~M/,N
`t\PTH~·R S. ROSE:
`,l,\Mf':, ~·
`SNl,\I(
`NZ::O A. ISRAf -~;2:N
`DREW S.
`rl;>MIL-~O'l
`JEPRV
`'f. St,W!:'.LI.
`,R
`,101 .. N A.
`'>GA:JGA,
`lDWAPD A. SC.:HLAT ! ER
`GERf,,R[J VON HOFFl.tAl\'N
`~osF.P'·: R. R[
`CAT!tE.:m-J::: J HOLLMl'.J
`JOt-"l
`IJ. CARSON
`l(A~EN VO(,r:1 w~ II
`IL :rn,:PS-'.Hl
`ANr)R[W
`,EFF~:E·r L. VAt<
`t-OOSEAR
`r .. Al_li,;AN
`(lA.Nli":'
`fJ.t-.r.GtJ':R TC L GU\N
`STEf'HEI\' C. JENSE\l
`VI T ,)
`,~.
`II
`WIU ,AM H.
`'.':HRCVE
`L'l'~WA ••. U~L;R/,-SYME:S'
`STfVf~ J NA fAUPSl--:Y
`PAUL A. STC'.VART
`.'.)S'::.1'"1 F. JENtll"IG'.S
`CRAIG S SlHAMERS
`MlNCf..lARIC kAISER
`fl PENT lli';
`f1
`8,'l.clt(.'( !<
`
`THO~US F SMEGAL, JP.
`MIC:HAf.l H TRENHOLM
`l)IANf M Pft[D
`JON/1,THA:-.. A BARNE'!'
`RONAL[.l
`SCHOC:NS,\UM
`,JO!·F~
`-<ING
`:.<·
`rRFDER CK s Brnl<ETTA
`NANCY WAYS VENSKO
`JOHN~· ~,lfZE:.N1AN~,[R
`Af:.ffl S AKflTAf./
`G!NGER R
`JREGER
`··r·:JMAS
`r,
`... RNC,
`Dl,V!D N WE'$~
`DA~IEL HAf\f, ?HD.
`f.tU~.HlH/,USf_;<
`[J'.;,UGl.,\'5 G
`LCR: 1..:':E YAM/.TO
`MIC:-i,\l:L K n'.IED'~A\:)
`STEP~[~; M LOBB'M
`::-,TA,r;r:r R HAl.PERI\
`DAL[ C
`PH D
`L:.E
`',¥
`Dt tWRAH ~, Srfl-'Hf f-1[)
`R'CH,i-.rrn C CA\.U'Hl:.1.L
`M/,RK M A3U~1Etfl
`,l()N W GilJ~'KA
`PC Ii
`tJCLS:ti
`MM-ii<
`BENED.C"7", PH D
`ii
`PA,LJ_ N. COI\OV:'"R
`R03E~.,.. J, P.03":'
`r" u:.t:
`SJ>.8;~1::.
`KAROLIN':: A OEl.A"ffY
`JOIHi W HOLCOMB
`, MULL['-, 1:1, Pd I)
`J'Uit:'.:,
`
`ft LIMITC:D L 1\Bl:...ITY
`;,MHt~[l~S-llF' IN::LUIJ!r<G
`F'ROF[SSIONAL CORPORA.-:-l•J~lS
`
`PATENT, TRADEMARK AND COPYRIGHT CAUSES
`
`620 f\i::C:WP<'J~T CC:-l'-.TEP DRIV~
`
`JCS E:: H
`.JO 5 FP 'i
`-JiiLLIAM R
`GLE\ ·- NUTTAL_
`
`·"JEWr>ORT OC.1\t,:1~,
`
`:::;A:..IFORNI/\
`
`;)26t;,C•80"
`
`Fl\X :9~ ... 9) 760-.... ::J!.)02
`
`ltHER~::'::T
`
`'NWW Kf,-iOEl COV
`
`fA,D
`
`PH~
`
`Tlr.!ZA.H Ml:'"
`GEOf'F'REY Y 1l[)A
`,;.,LEXAfW~R S
`f.V•,NCO
`'',Atl,ll\i\:.'AL
`(,ll.l
`~~
`S .... ;';A~ V
`\103S
`JAMES W
`I
`P(lSE M
`Ml(:.IIA:'L l
`MICHA.;;L A GUILIM,A
`MARK J n.v,.,
`r.UIGINDF.:'.!
`~~ NARl;LA
`BRUCE S
`/"CHKAWITZ, Pr.()
`PET£,.' M M!DGLEY
`"4:"::Cl..[NA"lAN
`THliM>\S
`5,
`MICH/>,EL S Oc<AMOTO
`JOH'l 1,/ GROVER
`MA ... !.A-iv K Df 1'-H:Rl.l[R
`liF,\N /, LA TC er
`AM'!' C Ct-RlSTENSEN
`
`MA~K J GALLAGliCR, P'·I D
`Dt,V1D G J.".NKOWS'{I, P'"1 D
`BRIAN r HOR.\J[
`l'/,n;o-~ J LEM[ILLCUR
`WILL Af.'l G 3E.:..:1n
`DIANA W PR.r~::E
`
`Assistant Commissioner for Patents
`Washington, D.C. 20231
`
`CERTIFICATE OF MAILING BY "EXPRESS MAIL"
`
`Attorney Docket No.
`
`3WARE.011PR
`
`Applicants
`
`Jewett, ct al.
`
`EUROPEMJ PP.TENT ATTY
`1,,.~1\//Ti,\l
`,iEL.LE:BRM!!)"T
`KOREA'~ PAIEW"."" A ... ry
`MINCHEO·- Kli.'
`
`'.';Cl[NIISTS &.
`:N:".;INEThS
`(NOM-LA'v:YERS)
`
`kAllvlCi~I) J SA!.~'Nli:Ks"•
`~;Ell S GARTF"ELD. ~-ID~•
`DANIEL E
`PH D ••
`() H
`
`:;;,H 0
`l-',4HMfo.~,
`!<"liURf:iAM
`,,U,'NIFER /,, Hl,YNES, PH D
`e:,:u,DA~ F'
`,J NEI-L., l'-H C•
`T:iOMAS Y O.:AGP.T.ti.
`LIN)A H, LIU
`YASHWAMT VAISH~IAV, Pr' \l
`MEGU~• T !i,N/d1.A
`CHE S CH:'.RE'.il<IN, Pl D "'
`t;;i~lr'." W ARCHE-:OLD
`P• .. 111..!P C HARTST[1r,,·
`JULIE
`,\ HOf?PE.~
`Cr'RIS S
`:.ASTLE
`,l•\11.ff.5
`'i.' A,,'SI
`R P
`c,t..RO~, PH:)
`JENNIFER H".YE~
`!<" RK E
`
`:.lH 0
`
`LANG
`
`,i
`
`M::COLL~·IA
`~.!C>-lA,PDY
`
`y A. f'ROf"ESS!O"~/,L c:i 0,PORilTICN
`~ AV>O 0;\'<PISTt'.R AT LAW Cl.Ki
`~" ,.J S
`f:11'. Yf::J<. ,. AJ.,UJ f
`
`For
`
`ARCHITECTURE FOR PROVIDING
`BLOCK-LEVEL STORAGE ACCESS OVER
`SOCKET CONNECTIONS
`
`Attorney
`
`Ronald J. Schoenbaum
`
`"Express Mail"
`Mailing Label No.
`
`EL6 l 3493005US
`
`Date of Deposit
`
`August 11, 2000
`
`I hereby ce1iify that the accompanying
`
`Transmittal in Duplicate; Specification in 21 pages; 6 sheets of drawings; Check
`for Filing Fee; and a Return Prepaid Postcard are being deposited with the United
`States Postal Service "Express Mail Post Of1ice to Addressee" service under 37
`CFR 1.10 on the date indicated above and are addressed to the Assistant
`Commissioner for Patents, Washington, D.C. 20231.
`
`a£l~~
`
`ARTHUR GREENE
`
`H:\DOCS\ROS\ROS-2360.DOC\dns
`081100
`
`201 CALIFOR~IA STREET
`SUITE 1150
`SAN FRANCISCO, CAI..IF'ORNIA 94-111
`(415) 954-4114
`FAX (415) 954-4111
`
`501 WEST BROADWAY
`SUITE 1400
`SAN DIEGO, CALIFORNIA 92101
`{619) 235-85-50
`FAX (619) 235-0176
`
`3801 UNIVERSITY AVENUE
`SUITE 710
`RIVERSIDE 1 CALIFORNIA 92501
`(909) 781-9231
`F'AX (909) 7B1-45-07
`
`1900 AVENUE OF THE STARS
`SUITE 1425
`LOS ANGELES, CALIFORNIA 90067
`(310) 551-3450
`FAX (J10) 551-:345B
`
`Petitioners Microsoft Corporation and HP Inc. - Ex. 1030, p. iii
`
`

`

`3WARE.011PR
`
`PATENT
`
`ARCHITECTURE FOR PROVIDING BLOCK-LEVEL
`
`STORAGE ACCESS OVER SOCKET CONNECTIONS
`
`5
`
`10
`
`Field of the Invention
`
`Background of the Invention
`
`The present invention relates to storage systems for computer networks, and
`
`more specifically, relates to software architectures for providing block level access to
`
`storage resources on a network.
`
`Description of the Related Art
`
`Various types of architectures exist for allowing host computers to share hard
`
`disk drives and other storage resources on a computer network. One common type of
`
`architecture involves the use of a central file manager. One problem with this
`
`15
`
`architecture is that the failure of the central file manager can render the entire system
`
`inoperable. Another problem is that many software applications are not designed to use
`
`a central file manager.
`
`Some storage architectures overcome these deficiencies by allowing the host
`
`computers to access the storage resources directly over the network, without the use of a
`
`20
`
`central file manager. Typically, these architectures allow the host to access the storage
`
`resources over a network connection at the block level (as opposed to the file level).
`
`One problem with this type of architecture is that the failure of an input/output request
`
`can cause other pending requests from the same host to be delayed. Another problem is
`
`that the architecture is highly vulnerable to network failures. The present invention
`
`25
`
`addresses these problems.
`
`Summary of the Invention
`
`The present invention provides an architecture for providing block-level access
`
`to storage resources, such as disk arrays, over a computer network without the need for
`
`30
`
`a central file manager. An important aspect of the architecture is that concurrent
`
`input/output (I/0) requests from the same host computer are handled over separate
`
`-1-
`
`Petitioners Microsoft Corporation and HP Inc. - Ex. 1030, p. 1
`
`

`

`logical network connections or sockets (preferably TCP/IP sockets). For example, a
`
`given host can establish two sockets with a given block server (storage server), and use
`
`one socket to perform one I/O request while using the other socket to perform another
`
`I/O request. As a result, the failure or postponement of one I/O request does not block
`
`5
`
`or interfere with other I/O requests.
`
`Another aspect of the architecture is that the sockets can be established over
`
`multiple networks, including networks of different types and bandwidths, to provide
`
`increased fault tolerance. For example, a given host computer and block server can be
`
`connected by two networks that support the TCP/IP protocol, one of which may provide
`
`10
`
`a much lower transfer rate than the other. As long as one of these networks is
`
`functioning properly, the host will be able to establish a logical connection to the block
`
`server and execute I/O requests.
`
`In a preferred embodiment, the software architecture includes a host-side device
`
`driver and a host-side reader/writer component that run on the host computers. The
`
`15
`
`architecture also includes a server-side device driver and a server-side reader/writer
`
`component that run on the block servers. The reader/writer components are preferably
`
`executed as separate processes that are established in pairs ( one host-side reader/writer
`
`process and one server-side reader/writer process), with each pair dedicated to a
`
`respective socket over a network. For example, if two logical connections are
`
`20
`
`established between a given host computer and a given block server, each such socket
`
`will be managed by a different pair or reader/writer processes. The reader/writer
`
`processes and sockets preferably remain persistent over multiple 1/0 requests. The
`
`device drivers and reader/writer processes operate to export the block-level-access
`
`interface of the block servers to the host computers, so that the disk drives of the block
`
`25
`
`servers appear to the host computers as local storage resources.
`
`In operation, when a host computer generates an I/O request, the host's device
`
`driver assigns the 1/0 request to an available reader/writer pair. The reader/writer pair
`
`thereafter operates as a dedicated proxy of the host-side device driver to execute the I/O
`
`request over a dedicated TCP/IP socket. Specifically, the host-side reader/writer
`
`30
`
`process passes the I/O request over the socket to the server-side reader/writer process
`
`for delivery to the server-side device driver, and then handles any subsequent transfer of
`
`-2-
`
`Petitioners Microsoft Corporation and HP Inc. - Ex. 1030, p. 2
`
`

`

`I/O data over the socket. The architecture also allows multiple block servers to
`
`cooperate in satisfying an I/0 request.
`
`Because TCP/IP is used for communications between the host computers and
`
`block servers, a variety of network topologies can be used to interconnect the host
`
`5
`
`computers and the block servers of a given system. For example, for relatively small
`
`systems, the host computers and block servers can be interconnected by a hub, while for
`
`larger systems, the hub may be replaced by a switched.
`
`Brief Description of the Drawings
`
`10
`
`These and other features will now be described with reference to the drawings of
`
`a preferred embodiment of the invention, which are intended to illustrate, and not limit,
`
`the scope of the invention.
`
`Figure 1 illustrates the primary hardware components of an example system in
`
`which the invention may be embodied, including a host computer and a block server.
`
`15
`
`Figure 2 illustrates the software architecture of the system of Figure 1, including
`
`host-side and server-side device drivers and reader/writer (RW) components that operate
`
`according to the invention.
`
`Figure 3 illustrates examples of the types of network and network components
`
`that can be used to interconnect the host and block servers.
`
`20
`
`Figure 4 shows, in example form, how the concurrent socket connections are
`
`established between pairs of reader/writers.
`
`Figure 5 illustrates the flow of information between components when a host
`
`computer performs a read from a block server.
`
`Figure 6 illustrates the flow of information between components when a host
`
`25
`
`computer performs a write to a block server.
`
`Detailed Description of the Preferred Embodiment
`
`The following detailed desc1iption is directed to certain specific embodiments of
`
`the invention. However, the invention can be embodied in a multitude of different ways
`
`30
`
`as defined and covered by the claims.
`
`In this description, reference is made to the
`
`drawings wherein like components are designated with the like numerals throughout.
`
`-3-
`
`Petitioners Microsoft Corporation and HP Inc. - Ex. 1030, p. 3
`
`

`

`The present invention provides a system architecture for providing block-level
`
`storage access over one or more computer networks. The architecture is designed to
`
`incorporate any number of host computers and block servers communicating across a
`
`network or a combination of networks.
`
`5
`
`Depicted in Figure 1 are the hardware components of a typical system that
`
`embodies the invention. The system includes a host computer 102 and a block server
`
`104 interconnected by a network 100 via respective network cards 106. The host
`
`computer may be a standard PC or workstation configured to operate as a server or as a
`
`user computer. The block server 104 may be a network-attached storage box which
`
`10
`
`provides block-level data storage services for host computers on the network 100. In the
`
`illustrated embodiment, the block server 108 includes a disk array controller 110 that
`
`controls an array of disk drives. A disk array controller of the type described in
`
`International Patent Application WO 99/26150 may be used for this purpose. The block
`
`server also includes a CPU board 108 for executing device driver and related software.
`
`15
`
`In the preferred embodiment, the network 100 may be any type or combination
`
`of networks that supports TCP/IP sockets, including but not limited to Local Area
`
`Networks (LANs), Wide Area Network (W ANs), the Internet, and direct connections.
`
`The network is preferably a non-dedicated network, meaning that it is also used for
`
`general-purpose (non-storage-related) communications. As depicted by dashed lines in
`
`20
`
`Figure 1, the host and the block server 102, 104 may be interconnected a second
`
`network 100', using a second set of network cards 106', to provide increased fault
`
`tolerance (as described below). The two networks 100, 100' may be disparate networks
`
`that use different mediums and provide different transfer speeds. The network 100 will
`
`be described in more detail with reference to Figure 3.
`
`ZS
`
`The software components of the architecture are shown in Figure 2. The host
`
`side of the software architecture includes an operating system (0/S) 202 such as Unix,
`
`Windows NT, or Linux; a device driver 204 ("host driver") which communicates with
`
`the operating system; and a reader/writer (RW) component 200a which communicates
`
`with the host driver 204. The storage side of the software architecture includes a
`
`30
`
`reader/writer (RW) component 200b and a device driver 206 ("server driver") that are
`
`-4-
`
`Petitioners Microsoft Corporation and HP Inc. - Ex. 1030, p. 4
`
`

`

`executed by the CPU board 108 (Figure 1 ). The server driver 206 initiates disk
`
`operations in response to I/0 requests received from the server-side reader/writer 200b.
`
`The reader/writer components 200 are preferably executed as separate processes
`
`that are established in pairs ( one host-side reader/writer process and one server-side
`
`5
`
`reader/writer process), with each pair dedicated to a respective TCP/IP socket over a
`
`network 100. The host reader/writer 200a operates generally by "reading" 1/0 requests
`
`from the host driver 204, and ''writing" these requests onto the network 100. Similarly,
`
`the storage reader/writer 200b operates generally by reading I/0 requests from the
`
`network 100 and writing these requests to the server driver 206. This process can occur
`
`10
`
`simultaneously with transfers by other reader/writer pairs, and can occur in any
`
`direction across the network 100. The reader/writers 200 also preferably perform error
`
`checking of transferred 1/0 data.
`
`Each reader/writer process (and its corresponding socket) preferably remains
`
`persistent on its respective machine 102, 104, and processes I/0 requests one at-a-time
`
`15
`
`on a first-in-first-out basis until the connection fails or is terminated. A host computer
`
`102 establishes a socket by sending a service request over a dedicated configuration
`
`socket to the relevant block server. Once a socket connection is established between a
`
`reader/writer pair 200a, 200b, the socket handles bi-directional traffic between the host
`
`computer 102 and block server 104.
`
`20
`
`In the illustrated embodiment, the reader/writers 200 are processes that are
`
`separate from the host and server drivers 204, 206. The host-side and server-side
`reader/writers could alternatively be implemented, for example, as one or more of the
`
`following: (a) part of the host and server drivers 204, 206 (respectively), (b) separate
`device drivers, (c) separate kernel threads, (d) multiple threads within a single process,
`
`25
`
`(e) multiple threads within multiple processes, or (f) multiple processes within a single
`
`thread.
`
`A host computer 102 may establish multiple logical connections (sockets) to a
`
`given block server 104, and/or establish sockets to multiple different block servers (as
`
`discussed below). An important benefit of this feature is that it allows multiple I/0
`
`30
`
`requests from the same host to be processed concurrently ( each over a separate socket)
`
`in a non-blocking manner
`
`if one socket fails, the I/0 requests being performed over
`
`-5-
`
`Petitioners Microsoft Corporation and HP Inc. - Ex. 1030, p. 5
`
`

`

`other sockets are not affected. Each socket is managed by a respective reader/writer
`
`pair.
`
`Figure 3 is a diagram that shows some of the various networks 100 and network
`
`components that may be used to interconnect the host and block servers 102, 104 of a
`
`5
`
`given system. These include a hub 302 (commonly used to connect LAN segments), the
`
`Internet 304, a router 306 (a computer that forwards packets according to header
`
`information), a switch 308 (a device that filters and forwards packets between LAN
`
`segments), and a gateway 310 (a computer that interconnects two different types of
`
`networks). The system architecture allows any combination of these network options to
`
`10
`
`be used to interconnect a given host computer and block server.
`
`An important feature of the architecture is that when the network 100 becomes
`
`inundated with traffic, a network 100 administrator can either add network capabilities
`
`on the fly or change the network hardware without causing any loss of data. The host(cid:173)
`
`side and server-side software components are configured, using conventional methods,
`
`15
`
`to detect and use new network connections as they become available, and to retry
`
`operations until a connection is established. For example, a network administrator
`
`could initially coIU1ect thirty host computers 102 to a small number of block servers 104
`
`using a network hub 302. When the number of computers reaches a level at which the
`
`network hub is no longer suitable, a 1000-port switch could be added to the network 100
`
`20
`
`and the hub 302 removed without bringing the network off-line. The architecture
`
`functions this way because the host reader/writers 200a create a new sockets to the
`
`storage reader/writers 200b automatically as new physical coIU1ections become
`
`available.
`
`The architecture presents the storage resources to the host computers 102 as a
`
`25
`
`logically contiguous array of bytes which are only accessible in blocks (e.g., of 512
`
`bytes). The logical data strnctures of the implementation support byte level access, but
`
`disk drives typically export blocks which are of a predetermined size, in bytes. Thus, to
`
`access a given block, a block address (sector number) and a count of the number of
`
`blocks (sectors) is provided. The wire protocol exports a 64-bit byte level offset and 64
`
`30
`
`bit byte count which is translated from and to a sector address and sector count by the
`
`host and server drivers 204, 206, respectively. On write operations, the VO write data is
`
`-6-
`
`Petitioners Microsoft Corporation and HP Inc. - Ex. 1030, p. 6
`
`

`

`packaged into a block structure with a uniform and predetermined size, on the host side.
`
`When a socket is opened up to the storage side, the block is sent to the storage location
`
`and given an address. The architecture also allows data to be stored non-sequentially.
`
`Depicted in Figure 4 are sample socket connections 400 made by reader/writers
`
`5
`
`200 connecting over a network 100 to link host computers 102 to block servers 104. As
`
`mentioned above, the network 100 may actually consist of multiple networks, including
`
`fully redundant networks. Each host computer 102 can open one or more socket
`
`connections 400 (using corresponding reader/writer pairs) to any one or more block
`
`servers 104 as needed to process I/0 requests. New socket connections 400 can be
`
`10
`
`opened, for example, in response to long network response times, failed socket
`
`connections, the availability of new physical connections, and increases in I/0 requests.
`
`For example, a host computer 102 can initially open two sockets 400 to a first block
`
`server 104; and subsequently open two more sockets 400 to another block server 104 as
`
`additional storage resources are needed. Another host computer 102 may have open
`
`15
`
`sockets to the same set of block servers 104 as shown. As described above, each socket
`
`400 acts as an independent pipeline for handling I/0 requests, and remains open until
`
`either an error occurs or the host terminates the connection.
`
`Figures 5 and 6 illustrate a network storage protocol that may be used for I/0
`
`read operations and write operations (respectively) between a host computer 102 and a
`
`20
`
`block server 104 over a socket connection. Located at the tops of the vertical lines in
`
`Figures 5 and 6 are abbreviations that denote components as follows.
`
`OS = Operating System
`
`HD = Host Driver 204
`
`25
`
`HRW = Host Computer's Reader/Writer 200a
`
`N=Network
`
`SRW = Server Reader/Writer 200b (of block server)
`
`SD= Server Driver 206 (ofhlock server)
`
`30
`
`Time increases, but is not accurately represented, in these diagrams moving from top to
`
`bottom. Arrows from one vertical line to another generally represent the flow of
`
`-7-
`
`Petitioners Microsoft Corporation and HP Inc. - Ex. 1030, p. 7
`
`

`

`messages or data between components. An arrow that begins and ends at the same
`
`component (vertical line) represents an action performed by that component. The small
`
`circles in the figures represent rendezvous events.
`
`As shown in Figure 5, the host reader/writer (HRW) initially sends a request lH
`
`5
`
`to the host driver (HD) for an VO command packet, indicating that the socket is
`
`available for use. This step can be viewed in simple language as the message "if you
`
`have work to do, give it to me." The host driver eventually responds to this request by
`
`returning a command packet that specifies an VO request, as shown. As represented by
`
`the arrow labeled 2H, the host reader/writer (HRW) translates the command packet into
`
`10
`
`network-generalized order. This step allows different, cross platform, computer
`
`languages to function on a common network 100.
`
`The local computational
`
`transformation of a host command packet, or host language, to a network command
`
`packet, or network language, is architecture specific.
`
`At this point, the host reader/writer (HRW) generates two networks events, 3H
`
`15
`
`and 4H. Message 4H represents a post of a received network response packet, from 3h,
`
`across the network 100 and is discussed below. Message 3H represents where the
`
`network generalized command packet is written over a pre-existing "pinned-up" TCP/IP
`
`connection. In order for this transfer to occur, a rendezvous must take place with 1 S,
`
`which represents a network 100 request to receive the command packet. This request
`
`20
`
`1 S has the ability to wait indefinitely if there is no "work" to be done. Once the network
`
`100 rendezvous is satisfied, the command packet is received by the block server's
`
`reader/writer (SRW), and is re-translated by the SRW to the server-side language via
`
`step 2S. Step 2S is similar to the translation of the host command packet to a network
`
`command packet shown in 2H.
`
`25
`
`As further illustrated in Figure 5, message 3S represents the server-side
`
`reader/writer posting the command packet the server driver (SD) 206. Included in the
`
`command packet are the following: an VO unit number (a small integer that is a logical
`
`identifier for the underlying "disk" drive partition on any form of storage disks), a
`
`command (a small integer indicating the type of command, such as a read operation or a
`
`30
`
`write operation), a starting logical block address (an integer indicating the starting block
`
`-8-
`
`Petitioners Microsoft Corporation and HP Inc. - Ex. 1030, p. 8
`
`

`

`or sector for the I/0 operation), and the block count (an integer indicating the number of
`
`blocks or sectors for the I/0 operation).
`
`After the command packet is delivered to the server device driver (SD), a
`
`response is sent back to the server-side reader/writer (SRW). As depicted by 4S, the
`
`5
`
`server-side reader/writer transforms this response packet from storage-side order to
`
`network order via step 4s. Subsequently, as depicted by 5S and 6S, both a network
`
`write of the response packet (5S) and a network write of the TIO data from the read (6S)
`
`occur simultaneously.
`
`A rendezvous thereafter occurs between the response packet (5S) and the
`
`10
`
`network read request (4h), representing satisfaction of the network read request. This
`
`step is for two very specific reasons: to ensure that the network response packet contains
`
`completion status after it has been checked for errors. Second, in case the read
`
`operation failed, the protocol will not send the requested amount of data. After they
`
`meet, the network response packet is translated into the host response packet language
`
`15
`
`in SH.
`
`Next, there is a network read request 6H for the I/0 (read) data. This request 6H
`
`is satisfied by the network write 6S of the I/0 read data, causing the I/0 read data to be
`
`transferred to the host computer. Finally, in 7H, the host reader/writer notifies the host
`
`driver, and the host driver notifies the operating system, that the I/0 operation is
`
`20
`
`complete.
`
`With regard to the write operations shown in Figure 6, the steps are similar up
`
`through 3s. The description below will show the remaining steps with regard to the
`
`remaining I/0 data transfers and network 100 operations.
`
`The write data associated with this I/0 operation is received by the network 100
`
`25
`
`and a receive operation is posted by the storage system 104 to the network 100 in step
`
`3S. This network read occurs subsequent to the translation of the network command
`
`packet to storage system language in step 2S. This ensures that a network read operation
`
`is posted for the proper size subsequent to error checking of the network command
`
`packet. In step 4S, the storage server 104 sends the storage system command packet to
`
`30
`
`storage driver (SD). This command packet contains the same type of information as
`
`described for the read case. The SD returns a response packet subsequent to the logical
`
`-9-
`
`Petitioners Microsoft Corporation and HP Inc. - Ex. 1030, p. 9
`
`

`

`( or physical) completion of the specified write operation which is subsequently
`
`converted to network order in step 5S. This network response packet is sent to the host
`
`computer102 via a send to network command in step 6S. This network response packet
`
`is received by the host computer 102 and translated to a host response packet in step 6H.
`
`5
`
`Subsequently, the host computer 102 sends a command to the HD to complete the 1/0
`
`operation. Steps 6H and 7H are similar to the read operation in Figure 5 where the host
`
`reader/writer notifies the host driver, and the host driver notifies the operating system,
`
`that the 1/0 operation is complete.
`
`Additional details of the read and write operations are included in the attached
`
`10
`
`appendices, which form part of the disclosure of the application.
`
`-10-
`
`Petitioners Microsoft Corporation and HP Inc. - Ex. 1030, p. 10
`
`

`

`APPENDIX A
`
`The following is a pseudocode representation of the host side logic, including
`
`error checking, with comments.
`
`5
`
`10
`
`15
`
`20
`
`25
`
`30
`
`35
`
`40
`
`45
`
`50
`
`/*
`* TI1is is the host side (h-box) data transfer logic
`* including error checking and comments
`*/
`
`#define H_DBSIZE
`
`128*512/* 128 sectors of 512 bytes
`
`*/
`
`h _ cmclpackct is the host side c01m11ancl packet defined by the driver
`ncmdpacket is the network command packet defined by 3Ware
`
`struct
`
`hioctlbuf {
`pid _t
`ioc_pid;
`struct
`h_cmdpacket *ioc_cp;
`struct
`h_ cmdpacket *ioc _ rp;
`char
`*ioc dp;
`} iocbuf;
`
`/* For debugging pmposes */
`/* Co1mnand packet pointer*/
`/* Response packet pointer
`/* Data pointer
`*/
`
`*/
`
`static
`
`pid_t mypid - (pid_t)O;
`
`struct
`struct
`char
`int
`
`h_cmdpacket h _ command, h _response, *cpp, *rpp;
`n_cmdpacketn_command, n_response, *ncpp, *nrpp;
`h_databufIH_DBSIZE];
`ret;
`
`mypid = mypid '? mypid : getpid();
`cpp
`&h _ command;
`ncpp
`&n _ command;
`= &h_response;
`rpp
`nrpp
`&n_response;
`
`iocbufiocpid
`iocbuf.ioc _ cp
`iocbuf.ioc_rp
`iocbuf.ioc _ dp
`
`=mypid;
`=cpp;
`=rpp;
`~ h _ databuf;
`
`while (more work to do) {
`/* (1) Issue the ioctl to fetch the command to process*/
`/* (1) The data comes "for free" on a write
`*/
`ret = ioct1(3whndd_fd, IOC_NEXTCMD, &iocbuf);
`if (ret} {
`
`error("Ioctl to fetch command failed");
`continue;
`
`}
`if (invalid_cmdpacket(cpp)) {
`error("Ioctl to fetch command returned invalid command
`packet");
`
`-11-
`
`Petitioners Microsoft Corporation and HP Inc. - Ex. 1030, p. 11
`
`

`

`5
`
`10
`
`15
`
`20
`
`25
`
`30
`
`35
`
`40
`
`45
`
`50
`
`55
`
`continue;
`
`}
`/* (2) transform the host command packet to a network command packet*/
`htoncmd(ncpp, cpp, connection_state);
`if (invalid_ ncmdpacket( cpp)) {
`c1Tor("Invalid transformation to netvwrk command packet");
`continue;
`
`}
`/* (3) Send the network command packet to the s-box * /
`ret write(s-box.socket_fd, ncpp, sizeof(*ncpp));
`if (sizeof(*ncpp) != ret) {
`error("Network command write failed");
`continue;
`
`}
`/* ( 4) Write the data to the network in the write case*/
`if (iswritc( cpp)) {
`ret = write( s-box.socket_fd, h _ databuf, write size( cpp ));
`if(writesize(cpp) !=ret) {
`error("Data write to network failed");
`continue;
`
`}
`/* (5) Read the response packet from the s-box side*/
`ret
`read(s-box.socket_fd, nrpp, sizeof(nrpp ));
`if (sizeof(*nrpp) != ret) {
`error(''Network response packet read from network failed");
`continue;
`
`}
`if (invalid~ nresponsepacket( nrpp)) {
`error("Invalid network response packet"):
`continue;
`
`}
`ntohresponse(nrpp, rpp, connection_ state);
`if ( invalid _responsepacket( rpp)) {
`error("lnvalid transformed network response packet");
`continue;
`
`}
`if (iosize(rpp) !~ iosize( cpp )) {
`error("Responsc and command io sizes diffcr\n");
`continue;
`
`}
`/* (6) Read the data (if required) from the s-box side*/
`if (isread(rpp )) {
`ret ~ read( s-box.sockcl_ fd, h~ databuf, readsize( rpp) );
`if(readsize(rpp) !=ret) {
`error("Data