]> git.proxmox.com Git - mirror_edk2.git/blob - NetworkPkg/IScsiDxe/IScsiProto.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
MdeModulePkg-DxeCore: rename CoreGetMemoryMapPropertiesTable
[mirror_edk2.git] / NetworkPkg / IScsiDxe / IScsiProto.c
1 /** @file
2 The implementation of iSCSI protocol based on RFC3720.
3
4 Copyright (c) 2004 - 2014, Intel Corporation. All rights reserved.<BR>
5 This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
9
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12
13 **/
14
15 #include "IScsiImpl.h"
16
17 UINT32 mDataSegPad = 0;
18
19 /**
20 Attach the iSCSI connection to the iSCSI session.
21
22 @param[in, out] Session The iSCSI session.
23 @param[in, out] Conn The iSCSI connection.
24
25 **/
26 VOID
27 IScsiAttatchConnection (
28 IN OUT ISCSI_SESSION *Session,
29 IN OUT ISCSI_CONNECTION *Conn
30 )
31 {
32 InsertTailList (&Session->Conns, &Conn->Link);
33 Conn->Session = Session;
34 Session->NumConns++;
35 }
36
37 /**
38 Detach the iSCSI connection from the session it belongs to.
39
40 @param[in, out] Conn The iSCSI connection.
41
42 **/
43 VOID
44 IScsiDetatchConnection (
45 IN OUT ISCSI_CONNECTION *Conn
46 )
47 {
48 RemoveEntryList (&Conn->Link);
49 Conn->Session->NumConns--;
50 Conn->Session = NULL;
51 }
52
53
54 /**
55 Check the sequence number according to RFC3720.
56
57 @param[in, out] ExpSN The currently expected sequence number.
58 @param[in] NewSN The sequence number to check.
59
60 @retval EFI_SUCCESS The check passed and the ExpSN is increased.
61 @retval EFI_NOT_READY Response was sent due to a retransmission request.
62 @retval EFI_PROTOCOL_ERROR Some kind of iSCSI protocol error occurred.
63
64 **/
65 EFI_STATUS
66 IScsiCheckSN (
67 IN OUT UINT32 *ExpSN,
68 IN UINT32 NewSN
69 )
70 {
71 if (!ISCSI_SEQ_EQ (NewSN, *ExpSN)) {
72 if (ISCSI_SEQ_LT (NewSN, *ExpSN)) {
73 //
74 // Duplicate
75 //
76 return EFI_NOT_READY;
77 } else {
78 return EFI_PROTOCOL_ERROR;
79 }
80 } else {
81 //
82 // Advance the ExpSN
83 //
84 (*ExpSN)++;
85 return EFI_SUCCESS;
86 }
87 }
88
89
90 /**
91 Update the sequence numbers for the iSCSI command.
92
93 @param[in, out] Session The iSCSI session.
94 @param[in] MaxCmdSN Maximum CmdSN from the target.
95 @param[in] ExpCmdSN Next expected CmdSN from the target.
96
97 **/
98 VOID
99 IScsiUpdateCmdSN (
100 IN OUT ISCSI_SESSION *Session,
101 IN UINT32 MaxCmdSN,
102 IN UINT32 ExpCmdSN
103 )
104 {
105 if (ISCSI_SEQ_LT (MaxCmdSN, ExpCmdSN - 1)) {
106 return ;
107 }
108
109 if (ISCSI_SEQ_GT (MaxCmdSN, Session->MaxCmdSN)) {
110 Session->MaxCmdSN = MaxCmdSN;
111 }
112
113 if (ISCSI_SEQ_GT (ExpCmdSN, Session->ExpCmdSN)) {
114 Session->ExpCmdSN = ExpCmdSN;
115 }
116 }
117
118
119 /**
120 This function does the iSCSI connection login.
121
122 @param[in, out] Conn The iSCSI connection to login.
123 @param Timeout The timeout value in millisecond.
124
125 @retval EFI_SUCCESS The iSCSI connection is logged into the iSCSI target.
126 @retval EFI_TIMEOUT Timeout occurred during the login procedure.
127 @retval Others Other errors as indicated.
128
129 **/
130 EFI_STATUS
131 IScsiConnLogin (
132 IN OUT ISCSI_CONNECTION *Conn,
133 IN UINT16 Timeout
134 )
135 {
136 EFI_STATUS Status;
137
138 //
139 // Start the timer, and wait Timeout seconds to establish the TCP connection.
140 //
141 Status = gBS->SetTimer (Conn->TimeoutEvent, TimerRelative, Timeout * TICKS_PER_MS);
142 if (EFI_ERROR (Status)) {
143 return Status;
144 }
145
146 //
147 // Try to establish the tcp connection.
148 //
149 Status = TcpIoConnect (&Conn->TcpIo, Conn->TimeoutEvent);
150 gBS->SetTimer (Conn->TimeoutEvent, TimerCancel, 0);
151
152 if (EFI_ERROR (Status)) {
153 return Status;
154 }
155
156 Conn->State = CONN_STATE_IN_LOGIN;
157
158 //
159 // Connection is established, start the iSCSI Login.
160 //
161 do {
162 Status = IScsiSendLoginReq (Conn);
163 if (EFI_ERROR (Status)) {
164 break;
165 }
166
167 Status = IScsiReceiveLoginRsp (Conn);
168 if (EFI_ERROR (Status)) {
169 break;
170 }
171 } while (Conn->CurrentStage != ISCSI_FULL_FEATURE_PHASE);
172
173 return Status;
174 }
175
176
177 /**
178 Reset the iSCSI connection.
179
180 @param[in, out] Conn The iSCSI connection to reset.
181
182 **/
183 VOID
184 IScsiConnReset (
185 IN OUT ISCSI_CONNECTION *Conn
186 )
187 {
188 TcpIoReset (&Conn->TcpIo);
189 }
190
191
192 /**
193 Create a TCP connection for the iSCSI session.
194
195 @param[in] Session Points to the iSCSI session.
196
197 @return The newly created iSCSI connection.
198
199 **/
200 ISCSI_CONNECTION *
201 IScsiCreateConnection (
202 IN ISCSI_SESSION *Session
203 )
204 {
205 ISCSI_DRIVER_DATA *Private;
206 ISCSI_SESSION_CONFIG_NVDATA *NvData;
207 ISCSI_CONNECTION *Conn;
208 TCP_IO_CONFIG_DATA TcpIoConfig;
209 TCP4_IO_CONFIG_DATA *Tcp4IoConfig;
210 TCP6_IO_CONFIG_DATA *Tcp6IoConfig;
211 EFI_STATUS Status;
212
213 Private = Session->Private;
214 NvData = &Session->ConfigData->SessionConfigData;
215
216 Conn = AllocateZeroPool (sizeof (ISCSI_CONNECTION));
217 if (Conn == NULL) {
218 return NULL;
219 }
220
221 Conn->Signature = ISCSI_CONNECTION_SIGNATURE;
222 Conn->State = CONN_STATE_FREE;
223 Conn->CurrentStage = ISCSI_SECURITY_NEGOTIATION;
224 Conn->NextStage = ISCSI_LOGIN_OPERATIONAL_NEGOTIATION;
225 Conn->AuthStep = ISCSI_AUTH_INITIAL;
226 Conn->ExpStatSN = 0;
227 Conn->PartialReqSent = FALSE;
228 Conn->PartialRspRcvd = FALSE;
229 Conn->ParamNegotiated = FALSE;
230 Conn->Cid = Session->NextCid++;
231 Conn->Ipv6Flag = NvData->IpMode == IP_MODE_IP6 || Session->ConfigData->AutoConfigureMode == IP_MODE_AUTOCONFIG_IP6;
232
233 Status = gBS->CreateEvent (
234 EVT_TIMER,
235 TPL_CALLBACK,
236 NULL,
237 NULL,
238 &Conn->TimeoutEvent
239 );
240 if (EFI_ERROR (Status)) {
241 FreePool (Conn);
242 return NULL;
243 }
244
245 NetbufQueInit (&Conn->RspQue);
246
247 //
248 // Set the default connection-only parameters.
249 //
250 Conn->MaxRecvDataSegmentLength = DEFAULT_MAX_RECV_DATA_SEG_LEN;
251 Conn->HeaderDigest = IScsiDigestNone;
252 Conn->DataDigest = IScsiDigestNone;
253
254 if (!Conn->Ipv6Flag) {
255 Tcp4IoConfig = &TcpIoConfig.Tcp4IoConfigData;
256
257 CopyMem (&Tcp4IoConfig->LocalIp, &NvData->LocalIp, sizeof (EFI_IPv4_ADDRESS));
258 CopyMem (&Tcp4IoConfig->SubnetMask, &NvData->SubnetMask, sizeof (EFI_IPv4_ADDRESS));
259 CopyMem (&Tcp4IoConfig->Gateway, &NvData->Gateway, sizeof (EFI_IPv4_ADDRESS));
260 CopyMem (&Tcp4IoConfig->RemoteIp, &NvData->TargetIp, sizeof (EFI_IPv4_ADDRESS));
261
262 Tcp4IoConfig->RemotePort = NvData->TargetPort;
263 Tcp4IoConfig->ActiveFlag = TRUE;
264 Tcp4IoConfig->StationPort = 0;
265 } else {
266 Tcp6IoConfig = &TcpIoConfig.Tcp6IoConfigData;
267
268 CopyMem (&Tcp6IoConfig->RemoteIp, &NvData->TargetIp, sizeof (EFI_IPv6_ADDRESS));
269 Tcp6IoConfig->RemotePort = NvData->TargetPort;
270 Tcp6IoConfig->ActiveFlag = TRUE;
271 Tcp6IoConfig->StationPort = 0;
272 }
273
274 //
275 // Create the TCP IO for this connection.
276 //
277 Status = TcpIoCreateSocket (
278 Private->Image,
279 Private->Controller,
280 (UINT8) (!Conn->Ipv6Flag ? TCP_VERSION_4: TCP_VERSION_6),
281 &TcpIoConfig,
282 &Conn->TcpIo
283 );
284 if (EFI_ERROR (Status)) {
285 gBS->CloseEvent (Conn->TimeoutEvent);
286 FreePool (Conn);
287 Conn = NULL;
288 }
289
290 return Conn;
291 }
292
293
294 /**
295 Destroy an iSCSI connection.
296
297 @param[in] Conn The connection to destroy.
298
299 **/
300 VOID
301 IScsiDestroyConnection (
302 IN ISCSI_CONNECTION *Conn
303 )
304 {
305 TcpIoDestroySocket (&Conn->TcpIo);
306
307 NetbufQueFlush (&Conn->RspQue);
308 gBS->CloseEvent (Conn->TimeoutEvent);
309 FreePool (Conn);
310 }
311
312 /**
313 Retrieve the IPv6 Address/Prefix/Gateway from the established TCP connection, these informations
314 will be filled in the iSCSI Boot Firmware Table.
315
316 @param[in] Conn The connection used in the iSCSI login phase.
317
318 @retval EFI_SUCCESS Get the NIC information successfully.
319 @retval Others Other errors as indicated.
320
321 **/
322 EFI_STATUS
323 IScsiGetIp6NicInfo (
324 IN ISCSI_CONNECTION *Conn
325 )
326 {
327 ISCSI_SESSION_CONFIG_NVDATA *NvData;
328 EFI_TCP6_PROTOCOL *Tcp6;
329 EFI_IP6_MODE_DATA Ip6ModeData;
330 EFI_STATUS Status;
331 EFI_IPv6_ADDRESS *TargetIp;
332 UINTN Index;
333 UINT8 SubnetPrefixLength;
334 UINTN RouteEntry;
335
336 NvData = &Conn->Session->ConfigData->SessionConfigData;
337 TargetIp = &NvData->TargetIp.v6;
338 Tcp6 = Conn->TcpIo.Tcp.Tcp6;
339
340 ZeroMem (&Ip6ModeData, sizeof (EFI_IP6_MODE_DATA));
341 Status = Tcp6->GetModeData (
342 Tcp6,
343 NULL,
344 NULL,
345 &Ip6ModeData,
346 NULL,
347 NULL
348 );
349 if (EFI_ERROR (Status)) {
350 return Status;
351 }
352
353 if (!Ip6ModeData.IsConfigured) {
354 Status = EFI_ABORTED;
355 goto ON_EXIT;
356 }
357
358 IP6_COPY_ADDRESS (&NvData->LocalIp, &Ip6ModeData.ConfigData.StationAddress);
359
360 NvData->PrefixLength = 0;
361 for (Index = 0; Index < Ip6ModeData.AddressCount; Index++) {
362 if (EFI_IP6_EQUAL (&NvData->LocalIp.v6, &Ip6ModeData.AddressList[Index].Address)) {
363 NvData->PrefixLength = Ip6ModeData.AddressList[Index].PrefixLength;
364 break;
365 }
366 }
367
368 SubnetPrefixLength = 0;
369 RouteEntry = Ip6ModeData.RouteCount;
370 for (Index = 0; Index < Ip6ModeData.RouteCount; Index++) {
371 if (NetIp6IsNetEqual (TargetIp, &Ip6ModeData.RouteTable[Index].Destination, Ip6ModeData.RouteTable[Index].PrefixLength)) {
372 if (SubnetPrefixLength < Ip6ModeData.RouteTable[Index].PrefixLength) {
373 SubnetPrefixLength = Ip6ModeData.RouteTable[Index].PrefixLength;
374 RouteEntry = Index;
375 }
376 }
377 }
378 if (RouteEntry != Ip6ModeData.RouteCount) {
379 IP6_COPY_ADDRESS (&NvData->Gateway, &Ip6ModeData.RouteTable[RouteEntry].Gateway);
380 }
381
382 ON_EXIT:
383 if (Ip6ModeData.AddressList != NULL) {
384 FreePool (Ip6ModeData.AddressList);
385 }
386 if (Ip6ModeData.GroupTable!= NULL) {
387 FreePool (Ip6ModeData.GroupTable);
388 }
389 if (Ip6ModeData.RouteTable!= NULL) {
390 FreePool (Ip6ModeData.RouteTable);
391 }
392 if (Ip6ModeData.NeighborCache!= NULL) {
393 FreePool (Ip6ModeData.NeighborCache);
394 }
395 if (Ip6ModeData.PrefixTable!= NULL) {
396 FreePool (Ip6ModeData.PrefixTable);
397 }
398 if (Ip6ModeData.IcmpTypeList!= NULL) {
399 FreePool (Ip6ModeData.IcmpTypeList);
400 }
401
402 return Status;
403 }
404
405 /**
406 Login the iSCSI session.
407
408 @param[in] Session The iSCSI session.
409
410 @retval EFI_SUCCESS The iSCSI session login procedure finished.
411 @retval EFI_OUT_OF_RESOURCES Failed to allocate memory.
412 @retval EFI_NO_MEDIA There was a media error.
413 @retval Others Other errors as indicated.
414
415 **/
416 EFI_STATUS
417 IScsiSessionLogin (
418 IN ISCSI_SESSION *Session
419 )
420 {
421 EFI_STATUS Status;
422 ISCSI_CONNECTION *Conn;
423 VOID *Tcp;
424 EFI_GUID *ProtocolGuid;
425 UINT8 RetryCount;
426 BOOLEAN MediaPresent;
427
428 //
429 // Check media status before session login.
430 //
431 MediaPresent = TRUE;
432 NetLibDetectMedia (Session->Private->Controller, &MediaPresent);
433 if (!MediaPresent) {
434 return EFI_NO_MEDIA;
435 }
436
437 //
438 // Set session identifier
439 //
440 CopyMem (Session->Isid, Session->ConfigData->SessionConfigData.IsId, 6);
441
442 RetryCount = 0;
443
444 do {
445 //
446 // Create a connection for the session.
447 //
448 Conn = IScsiCreateConnection (Session);
449 if (Conn == NULL) {
450 return EFI_OUT_OF_RESOURCES;
451 }
452
453 IScsiAttatchConnection (Session, Conn);
454
455 //
456 // Login througth the newly created connection.
457 //
458 Status = IScsiConnLogin (Conn, Session->ConfigData->SessionConfigData.ConnectTimeout);
459 if (EFI_ERROR (Status)) {
460 IScsiConnReset (Conn);
461 IScsiDetatchConnection (Conn);
462 IScsiDestroyConnection (Conn);
463 }
464
465 if (Status != EFI_TIMEOUT) {
466 break;
467 }
468
469 RetryCount++;
470 } while (RetryCount <= Session->ConfigData->SessionConfigData.ConnectRetryCount);
471
472 if (!EFI_ERROR (Status)) {
473 Session->State = SESSION_STATE_LOGGED_IN;
474
475 if (!Conn->Ipv6Flag) {
476 ProtocolGuid = &gEfiTcp4ProtocolGuid;
477 } else {
478 ProtocolGuid = &gEfiTcp6ProtocolGuid;
479 }
480
481 Status = gBS->OpenProtocol (
482 Conn->TcpIo.Handle,
483 ProtocolGuid,
484 (VOID **) &Tcp,
485 Session->Private->Image,
486 Session->Private->ExtScsiPassThruHandle,
487 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
488 );
489
490 ASSERT_EFI_ERROR (Status);
491
492 if (Conn->Ipv6Flag) {
493 Status = IScsiGetIp6NicInfo (Conn);
494 }
495 }
496
497 return Status;
498 }
499
500
501 /**
502 Wait for IPsec negotiation, then try to login the iSCSI session again.
503
504 @param[in] Session The iSCSI session.
505
506 @retval EFI_SUCCESS The iSCSI session login procedure finished.
507 @retval EFI_OUT_OF_RESOURCES Failed to allocate memory.
508 @retval EFI_PROTOCOL_ERROR Some kind of iSCSI protocol error occurred.
509
510 **/
511 EFI_STATUS
512 IScsiSessionReLogin (
513 IN ISCSI_SESSION *Session
514 )
515 {
516
517 EFI_STATUS Status;
518 EFI_STATUS TimerStatus;
519 EFI_EVENT Timer;
520
521 Status = gBS->CreateEvent (EVT_TIMER, TPL_CALLBACK, NULL, NULL, &Timer);
522 if (EFI_ERROR (Status)) {
523 return Status;
524 }
525
526 Status = gBS->SetTimer (
527 Timer,
528 TimerRelative,
529 ISCSI_WAIT_IPSEC_TIMEOUT
530 );
531
532 if (EFI_ERROR (Status)) {
533 gBS->CloseEvent (Timer);
534 return Status;
535 }
536
537 do {
538
539 TimerStatus = gBS->CheckEvent (Timer);
540
541 if (!EFI_ERROR (TimerStatus)) {
542 Status = IScsiSessionLogin (Session);
543 }
544
545 } while (TimerStatus == EFI_NOT_READY);
546
547 gBS->CloseEvent (Timer);
548 return Status;
549 }
550
551
552 /**
553 Build and send the iSCSI login request to the iSCSI target according to
554 the current login stage.
555
556 @param[in] Conn The connection in the iSCSI login phase.
557
558 @retval EFI_SUCCESS The iSCSI login request PDU is built and sent on this
559 connection.
560 @retval EFI_OUT_OF_RESOURCES Failed to allocate memory.
561 @retval EFI_DEVICE_ERROR Some kind of device error occurred.
562
563 **/
564 EFI_STATUS
565 IScsiSendLoginReq (
566 IN ISCSI_CONNECTION *Conn
567 )
568 {
569 NET_BUF *Pdu;
570 EFI_STATUS Status;
571
572 //
573 // Build the Login Request PDU.
574 //
575 Pdu = IScsiPrepareLoginReq (Conn);
576 if (Pdu == NULL) {
577 return EFI_DEVICE_ERROR;
578 }
579 //
580 // Send it to the iSCSI target.
581 //
582 Status = TcpIoTransmit (&Conn->TcpIo, Pdu);
583
584 NetbufFree (Pdu);
585
586 return Status;
587 }
588
589
590 /**
591 Receive and process the iSCSI login response.
592
593 @param[in] Conn The connection in the iSCSI login phase.
594
595 @retval EFI_SUCCESS The iSCSI login response PDU is received and processed.
596 @retval Others Other errors as indicated.
597
598 **/
599 EFI_STATUS
600 IScsiReceiveLoginRsp (
601 IN ISCSI_CONNECTION *Conn
602 )
603 {
604 EFI_STATUS Status;
605 NET_BUF *Pdu;
606
607 Pdu = NULL;
608
609 //
610 // Receive the iSCSI login response.
611 //
612 Status = IScsiReceivePdu (Conn, &Pdu, NULL, FALSE, FALSE, NULL);
613 if (EFI_ERROR (Status)) {
614 return Status;
615 }
616 ASSERT (Pdu != NULL);
617
618 //
619 // A Login Response is received; process it.
620 //
621 Status = IScsiProcessLoginRsp (Conn, Pdu);
622
623 NetbufFree (Pdu);
624
625 return Status;
626 }
627
628
629 /**
630 Add an iSCSI key-value pair as a string into the data segment of the Login Request PDU.
631 The DataSegmentLength and the actual size of the net buffer containing this PDU will be
632 updated.
633
634 @param[in, out] Pdu The iSCSI PDU whose data segment the key-value pair will
635 be added to.
636 @param[in] Key The key name string.
637 @param[in] Value The value string.
638
639 @retval EFI_SUCCESS The key-value pair is added to the PDU's data segment and
640 the correspondence length fields are updated.
641 @retval EFI_OUT_OF_RESOURCES There is not enough space in the PDU to add the key-value
642 pair.
643 @retval EFI_PROTOCOL_ERROR There is no such data in the net buffer.
644 **/
645 EFI_STATUS
646 IScsiAddKeyValuePair (
647 IN OUT NET_BUF *Pdu,
648 IN CHAR8 *Key,
649 IN CHAR8 *Value
650 )
651 {
652 UINT32 DataSegLen;
653 UINT32 KeyLen;
654 UINT32 ValueLen;
655 UINT32 TotalLen;
656 ISCSI_LOGIN_REQUEST *LoginReq;
657 CHAR8 *Data;
658
659 LoginReq = (ISCSI_LOGIN_REQUEST *) NetbufGetByte (Pdu, 0, NULL);
660 if (LoginReq == NULL) {
661 return EFI_PROTOCOL_ERROR;
662 }
663 DataSegLen = NTOH24 (LoginReq->DataSegmentLength);
664
665 KeyLen = (UINT32) AsciiStrLen (Key);
666 ValueLen = (UINT32) AsciiStrLen (Value);
667
668 //
669 // 1 byte for the key value separator '=' and 1 byte for the null
670 // delimiter after the value.
671 //
672 TotalLen = KeyLen + 1 + ValueLen + 1;
673
674 //
675 // Allocate the space for the key-value pair.
676 //
677 Data = (CHAR8 *) NetbufAllocSpace (Pdu, TotalLen, NET_BUF_TAIL);
678 if (Data == NULL) {
679 return EFI_OUT_OF_RESOURCES;
680 }
681 //
682 // Add the key.
683 //
684 CopyMem (Data, Key, KeyLen);
685 Data += KeyLen;
686
687 *Data = '=';
688 Data++;
689
690 //
691 // Add the value.
692 //
693 CopyMem (Data, Value, ValueLen);
694 Data += ValueLen;
695
696 *Data = '\0';
697
698 //
699 // Update the DataSegmentLength
700 //
701 ISCSI_SET_DATASEG_LEN (LoginReq, DataSegLen + TotalLen);
702
703 return EFI_SUCCESS;
704 }
705
706
707 /**
708 Prepare the iSCSI login request to be sent according to the current login status.
709
710 @param[in, out] Conn The connection in the iSCSI login phase.
711
712 @return The pointer to the net buffer containing the iSCSI login request built.
713 @retval NULL Other errors as indicated.
714
715 **/
716 NET_BUF *
717 IScsiPrepareLoginReq (
718 IN OUT ISCSI_CONNECTION *Conn
719 )
720 {
721 ISCSI_SESSION *Session;
722 NET_BUF *Nbuf;
723 ISCSI_LOGIN_REQUEST *LoginReq;
724 EFI_STATUS Status;
725
726 Session = Conn->Session;
727
728 Nbuf = NetbufAlloc (sizeof (ISCSI_LOGIN_REQUEST) + DEFAULT_MAX_RECV_DATA_SEG_LEN);
729 if (Nbuf == NULL) {
730 return NULL;
731 }
732
733 LoginReq = (ISCSI_LOGIN_REQUEST *) NetbufAllocSpace (Nbuf, sizeof (ISCSI_LOGIN_REQUEST), NET_BUF_TAIL);
734 ASSERT (LoginReq != NULL);
735 ZeroMem (LoginReq, sizeof (ISCSI_LOGIN_REQUEST));
736
737 //
738 // Init the login request pdu
739 //
740 ISCSI_SET_OPCODE (LoginReq, ISCSI_OPCODE_LOGIN_REQ, ISCSI_REQ_IMMEDIATE);
741 ISCSI_SET_STAGES (LoginReq, Conn->CurrentStage, Conn->NextStage);
742 LoginReq->VersionMax = ISCSI_VERSION_MAX;
743 LoginReq->VersionMin = ISCSI_VERSION_MIN;
744 LoginReq->Tsih = HTONS (Session->Tsih);
745 LoginReq->InitiatorTaskTag = HTONL (Session->InitiatorTaskTag);
746 LoginReq->Cid = HTONS (Conn->Cid);
747 LoginReq->CmdSN = HTONL (Session->CmdSN);
748
749 //
750 // For the first Login Request on a coonection this is ExpStatSN for the
751 // old connection, and this field is only valid if the Login Request restarts
752 // a connection.
753 // For subsequent Login Requests it is used to acknowledge the Login Responses
754 // with their increasing StatSN values.
755 //
756 LoginReq->ExpStatSN = HTONL (Conn->ExpStatSN);
757 CopyMem (LoginReq->Isid, Session->Isid, sizeof (LoginReq->Isid));
758
759 if (Conn->PartialRspRcvd) {
760 //
761 // A partial response. The initiator must send an empty Login Request.
762 //
763 return Nbuf;
764 }
765
766 Status = EFI_SUCCESS;
767
768 switch (Conn->CurrentStage) {
769 case ISCSI_SECURITY_NEGOTIATION:
770 //
771 // Both none authentication and CHAP authentication share the CHAP path.
772 //
773 //
774 if (Session->AuthType != ISCSI_AUTH_TYPE_KRB) {
775 Status = IScsiCHAPToSendReq (Conn, Nbuf);
776 }
777
778 break;
779
780 case ISCSI_LOGIN_OPERATIONAL_NEGOTIATION:
781 //
782 // Only negotiate the paramter once.
783 //
784 if (!Conn->ParamNegotiated) {
785 IScsiFillOpParams (Conn, Nbuf);
786 }
787
788 ISCSI_SET_FLAG (LoginReq, ISCSI_LOGIN_REQ_PDU_FLAG_TRANSIT);
789 break;
790
791 default:
792 //
793 // An error occurs...
794 //
795 Status = EFI_DEVICE_ERROR;
796 break;
797 }
798
799 if (EFI_ERROR (Status)) {
800 NetbufFree (Nbuf);
801 Nbuf = NULL;
802 } else {
803 //
804 // Pad the data segment if needed.
805 //
806 IScsiPadSegment (Nbuf, ISCSI_GET_DATASEG_LEN (LoginReq));
807 //
808 // Check whether we will issue the stage transition signal?
809 //
810 Conn->TransitInitiated = ISCSI_FLAG_ON (LoginReq, ISCSI_LOGIN_REQ_PDU_FLAG_TRANSIT);
811 }
812
813 return Nbuf;
814 }
815
816
817 /**
818 Process the iSCSI Login Response.
819
820 @param[in, out] Conn The connection on which the iSCSI login response is received.
821 @param[in, out] Pdu The iSCSI login response PDU.
822
823 @retval EFI_SUCCESS The iSCSI login response PDU is processed, and all checks are passed.
824 @retval EFI_PROTOCOL_ERROR Some kind of iSCSI protocol error occurred.
825 @retval EFI_MEDIA_CHANGED Target is redirected.
826 @retval Others Other errors as indicated.
827
828 **/
829 EFI_STATUS
830 IScsiProcessLoginRsp (
831 IN OUT ISCSI_CONNECTION *Conn,
832 IN OUT NET_BUF *Pdu
833 )
834 {
835 EFI_STATUS Status;
836 ISCSI_SESSION *Session;
837 ISCSI_LOGIN_RESPONSE *LoginRsp;
838 BOOLEAN Transit;
839 BOOLEAN Continue;
840 UINT8 CurrentStage;
841 UINT8 NextStage;
842 UINT8 *DataSeg;
843 UINT32 DataSegLen;
844
845 Status = EFI_SUCCESS;
846 Session = Conn->Session;
847
848 LoginRsp = (ISCSI_LOGIN_RESPONSE *) NetbufGetByte (Pdu, 0, NULL);
849 if (LoginRsp == NULL) {
850 return EFI_PROTOCOL_ERROR;
851 }
852 if (!ISCSI_CHECK_OPCODE (LoginRsp, ISCSI_OPCODE_LOGIN_RSP)) {
853 //
854 // It is not a Login Response.
855 //
856 return EFI_PROTOCOL_ERROR;
857 }
858 //
859 // Get the data segment, if any.
860 //
861 DataSegLen = ISCSI_GET_DATASEG_LEN (LoginRsp);
862 if (DataSegLen != 0) {
863 DataSeg = NetbufGetByte (Pdu, sizeof (ISCSI_LOGIN_RESPONSE), NULL);
864 } else {
865 DataSeg = NULL;
866 }
867 //
868 // Check the status class in the login response PDU.
869 //
870 switch (LoginRsp->StatusClass) {
871 case ISCSI_LOGIN_STATUS_SUCCESS:
872 //
873 // Just break here; the response and the data segment will be processed later.
874 //
875 break;
876
877 case ISCSI_LOGIN_STATUS_REDIRECTION:
878 //
879 // The target may be moved to a different address.
880 //
881 if (DataSeg == NULL) {
882 return EFI_PROTOCOL_ERROR;
883 }
884 //
885 // Process the TargetAddress key-value strings in the data segment to update the
886 // target address info.
887 //
888 Status = IScsiUpdateTargetAddress (Session, (CHAR8 *) DataSeg, DataSegLen);
889 if (EFI_ERROR (Status)) {
890 return Status;
891 }
892 //
893 // Session will be restarted on this error status because the Target is
894 // redirected by this Login Response.
895 //
896 return EFI_MEDIA_CHANGED;
897
898 default:
899 //
900 // Initiator Error, Target Error, or any other undefined error code.
901 //
902 return EFI_PROTOCOL_ERROR;
903 }
904 //
905 // The status is success; extract the wanted fields from the header segment.
906 //
907 Transit = ISCSI_FLAG_ON (LoginRsp, ISCSI_LOGIN_RSP_PDU_FLAG_TRANSIT);
908 Continue = ISCSI_FLAG_ON (LoginRsp, ISCSI_LOGIN_RSP_PDU_FLAG_CONTINUE);
909
910 CurrentStage = ISCSI_GET_CURRENT_STAGE (LoginRsp);
911 NextStage = ISCSI_GET_NEXT_STAGE (LoginRsp);
912
913 LoginRsp->InitiatorTaskTag = NTOHL (LoginRsp->InitiatorTaskTag);
914
915 if ((Transit && Continue) ||
916 (CurrentStage != Conn->CurrentStage) ||
917 (!Conn->TransitInitiated && Transit) ||
918 (Transit && (NextStage != Conn->NextStage)) ||
919 (CompareMem (Session->Isid, LoginRsp->Isid, sizeof (LoginRsp->Isid)) != 0) ||
920 (LoginRsp->InitiatorTaskTag != Session->InitiatorTaskTag)
921 ) {
922 //
923 // A Login Response with the C bit set to 1 MUST have the T bit set to 0.
924 // The CSG in the Login Response MUST be the same with the I-end of this connection.
925 // The T bit can't be 1 if the last Login Response sent by the initiator doesn't
926 // initiate the transistion.
927 // The NSG MUST be the same with the I-end of this connection if Transit is required.
928 // The ISID in the Login Response MUST be the same with this session.
929 //
930 return EFI_PROTOCOL_ERROR;
931 }
932
933 LoginRsp->StatSN = NTOHL (LoginRsp->StatSN);
934 LoginRsp->ExpCmdSN = NTOHL (LoginRsp->ExpCmdSN);
935 LoginRsp->MaxCmdSN = NTOHL (LoginRsp->MaxCmdSN);
936
937 if ((Conn->CurrentStage == ISCSI_SECURITY_NEGOTIATION) && (Conn->AuthStep == ISCSI_AUTH_INITIAL)) {
938 //
939 // If the Login Request is a leading Login Request, the target MUST use
940 // the value presented in CmdSN as the target value for ExpCmdSN.
941 //
942 if ((Session->State == SESSION_STATE_FREE) && (Session->CmdSN != LoginRsp->ExpCmdSN)) {
943 return EFI_PROTOCOL_ERROR;
944 }
945
946 //
947 // It's the initial Login Response, initialize the local ExpStatSN, MaxCmdSN
948 // and ExpCmdSN.
949 //
950 Conn->ExpStatSN = LoginRsp->StatSN + 1;
951 Session->MaxCmdSN = LoginRsp->MaxCmdSN;
952 Session->ExpCmdSN = LoginRsp->ExpCmdSN;
953 } else {
954 //
955 // Check the StatSN of this PDU.
956 //
957 Status = IScsiCheckSN (&Conn->ExpStatSN, LoginRsp->StatSN);
958 if (!EFI_ERROR (Status)) {
959 //
960 // Update the MaxCmdSN and ExpCmdSN.
961 //
962 IScsiUpdateCmdSN (Session, LoginRsp->MaxCmdSN, LoginRsp->ExpCmdSN);
963 } else {
964 return Status;
965 }
966 }
967 //
968 // Trim off the header segment.
969 //
970 NetbufTrim (Pdu, sizeof (ISCSI_LOGIN_RESPONSE), NET_BUF_HEAD);
971
972 //
973 // Queue this login response first in case it's a partial response so that
974 // later when the full response list is received we can combine these scattered
975 // responses' data segment and then process it.
976 //
977 NET_GET_REF (Pdu);
978 NetbufQueAppend (&Conn->RspQue, Pdu);
979
980 Conn->PartialRspRcvd = Continue;
981 if (Continue) {
982 //
983 // It is a partial response; must wait for another or more Request/Response
984 // conversations to get the full response.
985 //
986 return EFI_SUCCESS;
987 }
988
989 switch (CurrentStage) {
990 case ISCSI_SECURITY_NEGOTIATION:
991 //
992 // In security negotiation stage, let CHAP module handle it.
993 //
994 if (Session->AuthType != ISCSI_AUTH_TYPE_KRB) {
995 Status = IScsiCHAPOnRspReceived (Conn);
996 }
997 break;
998
999 case ISCSI_LOGIN_OPERATIONAL_NEGOTIATION:
1000 //
1001 // Response received with negotiation response on iSCSI parameters: check them.
1002 //
1003 Status = IScsiCheckOpParams (Conn);
1004 if (!EFI_ERROR (Status)) {
1005 Conn->ParamNegotiated = TRUE;
1006 }
1007
1008 break;
1009
1010 default:
1011 //
1012 // Should never get here.
1013 //
1014 Status = EFI_PROTOCOL_ERROR;
1015 break;
1016 }
1017
1018 if (Transit && (Status == EFI_SUCCESS)) {
1019 //
1020 // Do the state transition.
1021 //
1022 Conn->CurrentStage = Conn->NextStage;
1023
1024 if (Conn->CurrentStage == ISCSI_LOGIN_OPERATIONAL_NEGOTIATION) {
1025 Conn->NextStage = ISCSI_FULL_FEATURE_PHASE;
1026 } else {
1027 //
1028 // CurrentStage is iSCSI Full Feature. It is the Login-Final Response;
1029 // get the TSIH from the Login Response.
1030 //
1031 Session->Tsih = NTOHS (LoginRsp->Tsih);
1032 }
1033 }
1034 //
1035 // Flush the response(s) received.
1036 //
1037 NetbufQueFlush (&Conn->RspQue);
1038
1039 return Status;
1040 }
1041
1042
1043 /**
1044 Updated the target information according the data received in the iSCSI
1045 login response with an target redirection status.
1046
1047 @param[in, out] Session The iSCSI session.
1048 @param[in] Data The data segment that should contain the
1049 TargetAddress key-value list.
1050 @param[in] Len Length of the data.
1051
1052 @retval EFI_SUCCESS The target address is updated.
1053 @retval EFI_OUT_OF_RESOURCES Failed to allocate memory.
1054 @retval EFI_NOT_FOUND The TargetAddress key is not found.
1055 @retval Others Other errors as indicated.
1056
1057 **/
1058 EFI_STATUS
1059 IScsiUpdateTargetAddress (
1060 IN OUT ISCSI_SESSION *Session,
1061 IN CHAR8 *Data,
1062 IN UINT32 Len
1063 )
1064 {
1065 LIST_ENTRY *KeyValueList;
1066 CHAR8 *TargetAddress;
1067 CHAR8 *IpStr;
1068 EFI_STATUS Status;
1069 UINTN Number;
1070 UINT8 IpMode;
1071
1072 KeyValueList = IScsiBuildKeyValueList (Data, Len);
1073 if (KeyValueList == NULL) {
1074 return EFI_OUT_OF_RESOURCES;
1075 }
1076
1077 Status = EFI_NOT_FOUND;
1078
1079 while (TRUE) {
1080 TargetAddress = IScsiGetValueByKeyFromList (KeyValueList, ISCSI_KEY_TARGET_ADDRESS);
1081 if (TargetAddress == NULL) {
1082 break;
1083 }
1084
1085 if (!NET_IS_DIGIT (TargetAddress[0])) {
1086 //
1087 // The domainname of the target may be presented in three formats: a DNS host name,
1088 // a dotted-decimal IPv4 address, or a bracketed IPv6 address. Only accept dotted
1089 // IPv4 address.
1090 //
1091 continue;
1092 }
1093
1094 IpStr = TargetAddress;
1095
1096 while ((*TargetAddress != 0) && (*TargetAddress != ':') && (*TargetAddress != ',')) {
1097 //
1098 // NULL, ':', or ',' ends the IPv4 string.
1099 //
1100 TargetAddress++;
1101 }
1102
1103 if (*TargetAddress == ',') {
1104 //
1105 // Comma and the portal group tag MUST be ommitted if the TargetAddress is sent
1106 // as the result of a redirection.
1107 //
1108 continue;
1109 } else if (*TargetAddress == ':') {
1110 *TargetAddress = '\0';
1111
1112 TargetAddress++;
1113
1114 Number = AsciiStrDecimalToUintn (TargetAddress);
1115 if (Number > 0xFFFF) {
1116 continue;
1117 } else {
1118 Session->ConfigData->SessionConfigData.TargetPort = (UINT16) Number;
1119 }
1120 } else {
1121 //
1122 // The string only contains the IPv4 address. Use the well-known port.
1123 //
1124 Session->ConfigData->SessionConfigData.TargetPort = ISCSI_WELL_KNOWN_PORT;
1125 }
1126 //
1127 // Update the target IP address.
1128 //
1129 if (Session->ConfigData->SessionConfigData.IpMode < IP_MODE_AUTOCONFIG) {
1130 IpMode = Session->ConfigData->SessionConfigData.IpMode;
1131 } else {
1132 IpMode = Session->ConfigData->AutoConfigureMode;
1133 }
1134
1135 Status = IScsiAsciiStrToIp (
1136 IpStr,
1137 IpMode,
1138 &Session->ConfigData->SessionConfigData.TargetIp
1139 );
1140
1141 if (EFI_ERROR (Status)) {
1142 continue;
1143 } else {
1144 break;
1145 }
1146 }
1147
1148 IScsiFreeKeyValueList (KeyValueList);
1149
1150 return Status;
1151 }
1152
1153
1154 /**
1155 The callback function to free the net buffer list.
1156
1157 @param[in] Arg The opaque parameter.
1158
1159 **/
1160 VOID
1161 EFIAPI
1162 IScsiFreeNbufList (
1163 VOID *Arg
1164 )
1165 {
1166 ASSERT (Arg != NULL);
1167
1168 NetbufFreeList ((LIST_ENTRY *) Arg);
1169 FreePool (Arg);
1170 }
1171
1172
1173 /**
1174 The callback function called in NetBufFree; it does nothing.
1175
1176 @param[in] Arg The opaque parameter.
1177
1178 **/
1179 VOID
1180 EFIAPI
1181 IScsiNbufExtFree (
1182 VOID *Arg
1183 )
1184 {
1185 }
1186
1187
1188 /**
1189 Receive an iSCSI response PDU. An iSCSI response PDU contains an iSCSI PDU header and
1190 an optional data segment. The two parts will be put into two blocks of buffers in the
1191 net buffer. The digest check will be conducted in this function if needed and the digests
1192 will be trimmed from the PDU buffer.
1193
1194 @param[in] Conn The iSCSI connection to receive data from.
1195 @param[out] Pdu The received iSCSI pdu.
1196 @param[in] Context The context used to describe information on the caller provided
1197 buffer to receive data segment of the iSCSI pdu. It is optional.
1198 @param[in] HeaderDigest Whether there will be header digest received.
1199 @param[in] DataDigest Whether there will be data digest.
1200 @param[in] TimeoutEvent The timeout event. It is optional.
1201
1202 @retval EFI_SUCCESS An iSCSI pdu is received.
1203 @retval EFI_OUT_OF_RESOURCES Failed to allocate memory.
1204 @retval EFI_PROTOCOL_ERROR Some kind of iSCSI protocol error occurred.
1205 @retval Others Other errors as indicated.
1206
1207 **/
1208 EFI_STATUS
1209 IScsiReceivePdu (
1210 IN ISCSI_CONNECTION *Conn,
1211 OUT NET_BUF **Pdu,
1212 IN ISCSI_IN_BUFFER_CONTEXT *Context, OPTIONAL
1213 IN BOOLEAN HeaderDigest,
1214 IN BOOLEAN DataDigest,
1215 IN EFI_EVENT TimeoutEvent OPTIONAL
1216 )
1217 {
1218 LIST_ENTRY *NbufList;
1219 UINT32 Len;
1220 NET_BUF *PduHdr;
1221 UINT8 *Header;
1222 EFI_STATUS Status;
1223 UINT32 PadLen;
1224 UINT32 InDataOffset;
1225 NET_FRAGMENT Fragment[2];
1226 UINT32 FragmentCount;
1227 NET_BUF *DataSeg;
1228 UINT32 PadAndCRC32[2];
1229
1230 NbufList = AllocatePool (sizeof (LIST_ENTRY));
1231 if (NbufList == NULL) {
1232 return EFI_OUT_OF_RESOURCES;
1233 }
1234
1235 InitializeListHead (NbufList);
1236
1237 //
1238 // The header digest will be received together with the PDU header, if exists.
1239 //
1240 Len = sizeof (ISCSI_BASIC_HEADER) + (HeaderDigest ? sizeof (UINT32) : 0);
1241 PduHdr = NetbufAlloc (Len);
1242 if (PduHdr == NULL) {
1243 Status = EFI_OUT_OF_RESOURCES;
1244 goto ON_EXIT;
1245 }
1246
1247 Header = NetbufAllocSpace (PduHdr, Len, NET_BUF_TAIL);
1248 ASSERT (Header != NULL);
1249 InsertTailList (NbufList, &PduHdr->List);
1250
1251 //
1252 // First step, receive the BHS of the PDU.
1253 //
1254 Status = TcpIoReceive (&Conn->TcpIo, PduHdr, FALSE, TimeoutEvent);
1255
1256 if (EFI_ERROR (Status)) {
1257 goto ON_EXIT;
1258 }
1259
1260 if (HeaderDigest) {
1261 //
1262 // TODO: check the header-digest.
1263 //
1264 //
1265 // Trim off the digest.
1266 //
1267 NetbufTrim (PduHdr, sizeof (UINT32), NET_BUF_TAIL);
1268 }
1269
1270 Len = ISCSI_GET_DATASEG_LEN (Header);
1271 if (Len == 0) {
1272 //
1273 // No data segment.
1274 //
1275 goto FORM_PDU;
1276 }
1277 //
1278 // Get the length of the padding bytes of the data segment.
1279 //
1280 PadLen = ISCSI_GET_PAD_LEN (Len);
1281
1282 switch (ISCSI_GET_OPCODE (Header)) {
1283 case ISCSI_OPCODE_SCSI_DATA_IN:
1284 //
1285 // To reduce memory copy overhead, try to use the buffer described by Context
1286 // if the PDU is an iSCSI SCSI data.
1287 //
1288 InDataOffset = ISCSI_GET_BUFFER_OFFSET (Header);
1289 if ((Context == NULL) || ((InDataOffset + Len) > Context->InDataLen)) {
1290 Status = EFI_PROTOCOL_ERROR;
1291 goto ON_EXIT;
1292 }
1293
1294 Fragment[0].Len = Len;
1295 Fragment[0].Bulk = Context->InData + InDataOffset;
1296
1297 if (DataDigest || (PadLen != 0)) {
1298 //
1299 // The data segment is padded. Use two fragments to receive it:
1300 // the first to receive the useful data; the second to receive the padding.
1301 //
1302 Fragment[1].Len = PadLen + (DataDigest ? sizeof (UINT32) : 0);
1303 Fragment[1].Bulk = (UINT8 *)PadAndCRC32 + (4 - PadLen);
1304
1305 FragmentCount = 2;
1306 } else {
1307 FragmentCount = 1;
1308 }
1309
1310 DataSeg = NetbufFromExt (&Fragment[0], FragmentCount, 0, 0, IScsiNbufExtFree, NULL);
1311 if (DataSeg == NULL) {
1312 Status = EFI_OUT_OF_RESOURCES;
1313 goto ON_EXIT;
1314 }
1315
1316 break;
1317
1318 case ISCSI_OPCODE_SCSI_RSP:
1319 case ISCSI_OPCODE_NOP_IN:
1320 case ISCSI_OPCODE_LOGIN_RSP:
1321 case ISCSI_OPCODE_TEXT_RSP:
1322 case ISCSI_OPCODE_ASYNC_MSG:
1323 case ISCSI_OPCODE_REJECT:
1324 case ISCSI_OPCODE_VENDOR_T0:
1325 case ISCSI_OPCODE_VENDOR_T1:
1326 case ISCSI_OPCODE_VENDOR_T2:
1327 //
1328 // Allocate buffer to receive the data segment.
1329 //
1330 Len += PadLen + (DataDigest ? sizeof (UINT32) : 0);
1331 DataSeg = NetbufAlloc (Len);
1332 if (DataSeg == NULL) {
1333 Status = EFI_OUT_OF_RESOURCES;
1334 goto ON_EXIT;
1335 }
1336
1337 NetbufAllocSpace (DataSeg, Len, NET_BUF_TAIL);
1338 break;
1339
1340 default:
1341 Status = EFI_PROTOCOL_ERROR;
1342 goto ON_EXIT;
1343 }
1344
1345 InsertTailList (NbufList, &DataSeg->List);
1346
1347 //
1348 // Receive the data segment with the data digest, if any.
1349 //
1350 Status = TcpIoReceive (&Conn->TcpIo, DataSeg, FALSE, TimeoutEvent);
1351
1352 if (EFI_ERROR (Status)) {
1353 goto ON_EXIT;
1354 }
1355
1356 if (DataDigest) {
1357 //
1358 // TODO: Check the data digest.
1359 //
1360 NetbufTrim (DataSeg, sizeof (UINT32), NET_BUF_TAIL);
1361 }
1362
1363 if (PadLen != 0) {
1364 //
1365 // Trim off the padding bytes in the data segment.
1366 //
1367 NetbufTrim (DataSeg, PadLen, NET_BUF_TAIL);
1368 }
1369
1370 FORM_PDU:
1371 //
1372 // Form the pdu from a list of pdu segments.
1373 //
1374 *Pdu = NetbufFromBufList (NbufList, 0, 0, IScsiFreeNbufList, NbufList);
1375 if (*Pdu == NULL) {
1376 Status = EFI_OUT_OF_RESOURCES;
1377 }
1378
1379 ON_EXIT:
1380
1381 if (EFI_ERROR (Status)) {
1382 //
1383 // Free the Nbufs in this NbufList and the NbufList itself.
1384 //
1385 IScsiFreeNbufList (NbufList);
1386 }
1387
1388 return Status;
1389 }
1390
1391
1392 /**
1393 Check and get the result of the parameter negotiation.
1394
1395 @param[in, out] Conn The connection in iSCSI login.
1396
1397 @retval EFI_SUCCESS The parmeter check is passed and negotiation is finished.
1398 @retval EFI_PROTOCOL_ERROR Some kind of iSCSI protocol error occurred.
1399 @retval EFI_OUT_OF_RESOURCES Failed to allocate memory.
1400
1401 **/
1402 EFI_STATUS
1403 IScsiCheckOpParams (
1404 IN OUT ISCSI_CONNECTION *Conn
1405 )
1406 {
1407 EFI_STATUS Status;
1408 LIST_ENTRY *KeyValueList;
1409 CHAR8 *Data;
1410 UINT32 Len;
1411 ISCSI_SESSION *Session;
1412 CHAR8 *Value;
1413 UINTN NumericValue;
1414
1415 ASSERT (Conn->RspQue.BufNum != 0);
1416
1417 Session = Conn->Session;
1418
1419 Len = Conn->RspQue.BufSize;
1420 Data = AllocatePool (Len);
1421 if (Data == NULL) {
1422 return EFI_OUT_OF_RESOURCES;
1423 }
1424
1425 NetbufQueCopy (&Conn->RspQue, 0, Len, (UINT8 *) Data);
1426
1427 Status = EFI_PROTOCOL_ERROR;
1428
1429 //
1430 // Extract the Key-Value pairs into a list.
1431 //
1432 KeyValueList = IScsiBuildKeyValueList (Data, Len);
1433 if (KeyValueList == NULL) {
1434 FreePool (Data);
1435 return Status;
1436 }
1437 //
1438 // HeaderDigest
1439 //
1440 Value = IScsiGetValueByKeyFromList (KeyValueList, ISCSI_KEY_HEADER_DIGEST);
1441 if (Value == NULL) {
1442 goto ON_ERROR;
1443 }
1444
1445 if (AsciiStrCmp (Value, "CRC32") == 0) {
1446 if (Conn->HeaderDigest != IScsiDigestCRC32) {
1447 goto ON_ERROR;
1448 }
1449 } else if (AsciiStrCmp (Value, ISCSI_KEY_VALUE_NONE) == 0) {
1450 Conn->HeaderDigest = IScsiDigestNone;
1451 } else {
1452 goto ON_ERROR;
1453 }
1454 //
1455 // DataDigest
1456 //
1457 Value = IScsiGetValueByKeyFromList (KeyValueList, ISCSI_KEY_DATA_DIGEST);
1458 if (Value == NULL) {
1459 goto ON_ERROR;
1460 }
1461
1462 if (AsciiStrCmp (Value, "CRC32") == 0) {
1463 if (Conn->DataDigest != IScsiDigestCRC32) {
1464 goto ON_ERROR;
1465 }
1466 } else if (AsciiStrCmp (Value, ISCSI_KEY_VALUE_NONE) == 0) {
1467 Conn->DataDigest = IScsiDigestNone;
1468 } else {
1469 goto ON_ERROR;
1470 }
1471 //
1472 // ErrorRecoveryLevel: result fuction is Minimum.
1473 //
1474 Value = IScsiGetValueByKeyFromList (KeyValueList, ISCSI_KEY_ERROR_RECOVERY_LEVEL);
1475 if (Value == NULL) {
1476 goto ON_ERROR;
1477 }
1478
1479 NumericValue = IScsiNetNtoi (Value);
1480 if (NumericValue > 2) {
1481 goto ON_ERROR;
1482 }
1483
1484 Session->ErrorRecoveryLevel = (UINT8) MIN (Session->ErrorRecoveryLevel, NumericValue);
1485
1486 //
1487 // InitialR2T: result function is OR.
1488 //
1489 if (!Session->InitialR2T) {
1490 Value = IScsiGetValueByKeyFromList (KeyValueList, ISCSI_KEY_INITIAL_R2T);
1491 if (Value == NULL) {
1492 goto ON_ERROR;
1493 }
1494
1495 Session->InitialR2T = (BOOLEAN) (AsciiStrCmp (Value, "Yes") == 0);
1496 }
1497
1498 //
1499 // ImmediateData: result function is AND.
1500 //
1501 Value = IScsiGetValueByKeyFromList (KeyValueList, ISCSI_KEY_IMMEDIATE_DATA);
1502 if (Value == NULL) {
1503 goto ON_ERROR;
1504 }
1505
1506 Session->ImmediateData = (BOOLEAN) (Session->ImmediateData && (BOOLEAN) (AsciiStrCmp (Value, "Yes") == 0));
1507
1508 //
1509 // MaxRecvDataSegmentLength is declarative.
1510 //
1511 Value = IScsiGetValueByKeyFromList (KeyValueList, ISCSI_KEY_MAX_RECV_DATA_SEGMENT_LENGTH);
1512 if (Value != NULL) {
1513 Conn->MaxRecvDataSegmentLength = (UINT32) IScsiNetNtoi (Value);
1514 }
1515 //
1516 // MaxBurstLength: result funtion is Mininum.
1517 //
1518 Value = IScsiGetValueByKeyFromList (KeyValueList, ISCSI_KEY_MAX_BURST_LENGTH);
1519 if (Value == NULL) {
1520 goto ON_ERROR;
1521 }
1522
1523 NumericValue = IScsiNetNtoi (Value);
1524 Session->MaxBurstLength = (UINT32) MIN (Session->MaxBurstLength, NumericValue);
1525
1526 //
1527 // FirstBurstLength: result function is Minimum. Irrelevant when InitialR2T=Yes and
1528 // ImmediateData=No.
1529 //
1530 if (!(Session->InitialR2T && !Session->ImmediateData)) {
1531 Value = IScsiGetValueByKeyFromList (KeyValueList, ISCSI_KEY_FIRST_BURST_LENGTH);
1532 if (Value == NULL) {
1533 goto ON_ERROR;
1534 }
1535
1536 NumericValue = IScsiNetNtoi (Value);
1537 Session->FirstBurstLength = (UINT32) MIN (Session->FirstBurstLength, NumericValue);
1538 }
1539
1540 //
1541 // MaxConnections: result function is Minimum.
1542 //
1543 Value = IScsiGetValueByKeyFromList (KeyValueList, ISCSI_KEY_MAX_CONNECTIONS);
1544 if (Value == NULL) {
1545 goto ON_ERROR;
1546 }
1547
1548 NumericValue = IScsiNetNtoi (Value);
1549 if ((NumericValue == 0) || (NumericValue > 65535)) {
1550 goto ON_ERROR;
1551 }
1552
1553 Session->MaxConnections = (UINT32) MIN (Session->MaxConnections, NumericValue);
1554
1555 //
1556 // DataPDUInOrder: result function is OR.
1557 //
1558 if (!Session->DataPDUInOrder) {
1559 Value = IScsiGetValueByKeyFromList (KeyValueList, ISCSI_KEY_DATA_PDU_IN_ORDER);
1560 if (Value == NULL) {
1561 goto ON_ERROR;
1562 }
1563
1564 Session->DataPDUInOrder = (BOOLEAN) (AsciiStrCmp (Value, "Yes") == 0);
1565 }
1566
1567 //
1568 // DataSequenceInorder: result function is OR.
1569 //
1570 if (!Session->DataSequenceInOrder) {
1571 Value = IScsiGetValueByKeyFromList (KeyValueList, ISCSI_KEY_DATA_SEQUENCE_IN_ORDER);
1572 if (Value == NULL) {
1573 goto ON_ERROR;
1574 }
1575
1576 Session->DataSequenceInOrder = (BOOLEAN) (AsciiStrCmp (Value, "Yes") == 0);
1577 }
1578
1579 //
1580 // DefaultTime2Wait: result function is Maximum.
1581 //
1582 Value = IScsiGetValueByKeyFromList (KeyValueList, ISCSI_KEY_DEFAULT_TIME2WAIT);
1583 if (Value == NULL) {
1584 goto ON_ERROR;
1585 }
1586
1587 NumericValue = IScsiNetNtoi (Value);
1588 if (NumericValue == 0) {
1589 Session->DefaultTime2Wait = 0;
1590 } else if (NumericValue > 3600) {
1591 goto ON_ERROR;
1592 } else {
1593 Session->DefaultTime2Wait = (UINT32) MAX (Session->DefaultTime2Wait, NumericValue);
1594 }
1595 //
1596 // DefaultTime2Retain: result function is Minimum.
1597 //
1598 Value = IScsiGetValueByKeyFromList (KeyValueList, ISCSI_KEY_DEFAULT_TIME2RETAIN);
1599 if (Value == NULL) {
1600 goto ON_ERROR;
1601 }
1602
1603 NumericValue = IScsiNetNtoi (Value);
1604 if (NumericValue == 0) {
1605 Session->DefaultTime2Retain = 0;
1606 } else if (NumericValue > 3600) {
1607 goto ON_ERROR;
1608 } else {
1609 Session->DefaultTime2Retain = (UINT32) MIN (Session->DefaultTime2Retain, NumericValue);
1610 }
1611 //
1612 // MaxOutstandingR2T: result function is Minimum.
1613 //
1614 Value = IScsiGetValueByKeyFromList (KeyValueList, ISCSI_KEY_MAX_OUTSTANDING_R2T);
1615 if (Value == NULL) {
1616 goto ON_ERROR;
1617 }
1618
1619 NumericValue = IScsiNetNtoi (Value);
1620 if ((NumericValue == 0) || (NumericValue > 65535)) {
1621 goto ON_ERROR;
1622 }
1623
1624 Session->MaxOutstandingR2T = (UINT16) MIN (Session->MaxOutstandingR2T, NumericValue);
1625
1626 //
1627 // Remove declarative key-value pairs, if any.
1628 //
1629 IScsiGetValueByKeyFromList (KeyValueList, ISCSI_KEY_SESSION_TYPE);
1630 IScsiGetValueByKeyFromList (KeyValueList, ISCSI_KEY_TARGET_ALIAS);
1631 IScsiGetValueByKeyFromList (KeyValueList, ISCSI_KEY_TARGET_PORTAL_GROUP_TAG);
1632
1633
1634 //
1635 // Remove the key-value that may not needed for result function is OR.
1636 //
1637 IScsiGetValueByKeyFromList (KeyValueList, ISCSI_KEY_INITIAL_R2T);
1638 IScsiGetValueByKeyFromList (KeyValueList, ISCSI_KEY_DATA_PDU_IN_ORDER);
1639 IScsiGetValueByKeyFromList (KeyValueList, ISCSI_KEY_DATA_SEQUENCE_IN_ORDER);
1640
1641 //
1642 // Remove irrelevant parameter, if any.
1643 //
1644 if (Session->InitialR2T && !Session->ImmediateData) {
1645 IScsiGetValueByKeyFromList (KeyValueList, ISCSI_KEY_FIRST_BURST_LENGTH);
1646 }
1647
1648 if (IsListEmpty (KeyValueList)) {
1649 //
1650 // Succeed if no more keys in the list.
1651 //
1652 Status = EFI_SUCCESS;
1653 }
1654
1655 ON_ERROR:
1656
1657 IScsiFreeKeyValueList (KeyValueList);
1658
1659 FreePool (Data);
1660
1661 return Status;
1662 }
1663
1664
1665 /**
1666 Fill the operational parameters.
1667
1668 @param[in] Conn The connection in iSCSI login.
1669 @param[in, out] Pdu The iSCSI login request PDU to fill the parameters.
1670
1671 **/
1672 VOID
1673 IScsiFillOpParams (
1674 IN ISCSI_CONNECTION *Conn,
1675 IN OUT NET_BUF *Pdu
1676 )
1677 {
1678 ISCSI_SESSION *Session;
1679 CHAR8 Value[256];
1680
1681 Session = Conn->Session;
1682
1683 AsciiSPrint (Value, sizeof (Value), "%a", (Conn->HeaderDigest == IScsiDigestCRC32) ? "None,CRC32" : "None");
1684 IScsiAddKeyValuePair (Pdu, ISCSI_KEY_HEADER_DIGEST, Value);
1685
1686 AsciiSPrint (Value, sizeof (Value), "%a", (Conn->DataDigest == IScsiDigestCRC32) ? "None,CRC32" : "None");
1687 IScsiAddKeyValuePair (Pdu, ISCSI_KEY_DATA_DIGEST, Value);
1688
1689 AsciiSPrint (Value, sizeof (Value), "%d", Session->ErrorRecoveryLevel);
1690 IScsiAddKeyValuePair (Pdu, ISCSI_KEY_ERROR_RECOVERY_LEVEL, Value);
1691
1692 AsciiSPrint (Value, sizeof (Value), "%a", Session->InitialR2T ? "Yes" : "No");
1693 IScsiAddKeyValuePair (Pdu, ISCSI_KEY_INITIAL_R2T, Value);
1694
1695 AsciiSPrint (Value, sizeof (Value), "%a", Session->ImmediateData ? "Yes" : "No");
1696 IScsiAddKeyValuePair (Pdu, ISCSI_KEY_IMMEDIATE_DATA, Value);
1697
1698 AsciiSPrint (Value, sizeof (Value), "%d", MAX_RECV_DATA_SEG_LEN_IN_FFP);
1699 IScsiAddKeyValuePair (Pdu, ISCSI_KEY_MAX_RECV_DATA_SEGMENT_LENGTH, Value);
1700
1701 AsciiSPrint (Value, sizeof (Value), "%d", Session->MaxBurstLength);
1702 IScsiAddKeyValuePair (Pdu, ISCSI_KEY_MAX_BURST_LENGTH, Value);
1703
1704 AsciiSPrint (Value, sizeof (Value), "%d", Session->FirstBurstLength);
1705 IScsiAddKeyValuePair (Pdu, ISCSI_KEY_FIRST_BURST_LENGTH, Value);
1706
1707 AsciiSPrint (Value, sizeof (Value), "%d", Session->MaxConnections);
1708 IScsiAddKeyValuePair (Pdu, ISCSI_KEY_MAX_CONNECTIONS, Value);
1709
1710 AsciiSPrint (Value, sizeof (Value), "%a", Session->DataPDUInOrder ? "Yes" : "No");
1711 IScsiAddKeyValuePair (Pdu, ISCSI_KEY_DATA_PDU_IN_ORDER, Value);
1712
1713 AsciiSPrint (Value, sizeof (Value), "%a", Session->DataSequenceInOrder ? "Yes" : "No");
1714 IScsiAddKeyValuePair (Pdu, ISCSI_KEY_DATA_SEQUENCE_IN_ORDER, Value);
1715
1716 AsciiSPrint (Value, sizeof (Value), "%d", Session->DefaultTime2Wait);
1717 IScsiAddKeyValuePair (Pdu, ISCSI_KEY_DEFAULT_TIME2WAIT, Value);
1718
1719 AsciiSPrint (Value, sizeof (Value), "%d", Session->DefaultTime2Retain);
1720 IScsiAddKeyValuePair (Pdu, ISCSI_KEY_DEFAULT_TIME2RETAIN, Value);
1721
1722 AsciiSPrint (Value, sizeof (Value), "%d", Session->MaxOutstandingR2T);
1723 IScsiAddKeyValuePair (Pdu, ISCSI_KEY_MAX_OUTSTANDING_R2T, Value);
1724 }
1725
1726
1727 /**
1728 Pad the iSCSI AHS or data segment to an integer number of 4 byte words.
1729
1730 @param[in, out] Pdu The iSCSI pdu which contains segments to pad.
1731 @param[in] Len The length of the last segment in the PDU.
1732
1733 @retval EFI_SUCCESS The segment is padded or there is no need to pad it.
1734 @retval EFI_OUT_OF_RESOURCES There is not enough remaining free space to add the
1735 padding bytes.
1736 **/
1737 EFI_STATUS
1738 IScsiPadSegment (
1739 IN OUT NET_BUF *Pdu,
1740 IN UINT32 Len
1741 )
1742 {
1743 UINT32 PadLen;
1744 UINT8 *Data;
1745
1746 PadLen = ISCSI_GET_PAD_LEN (Len);
1747
1748 if (PadLen != 0) {
1749 Data = NetbufAllocSpace (Pdu, PadLen, NET_BUF_TAIL);
1750 if (Data == NULL) {
1751 return EFI_OUT_OF_RESOURCES;
1752 }
1753
1754 ZeroMem (Data, PadLen);
1755 }
1756
1757 return EFI_SUCCESS;
1758 }
1759
1760
1761 /**
1762 Build a key-value list from the data segment.
1763
1764 @param[in] Data The data segment containing the key-value pairs.
1765 @param[in] Len Length of the data segment.
1766
1767 @return The key-value list.
1768 @retval NULL Other errors as indicated.
1769
1770 **/
1771 LIST_ENTRY *
1772 IScsiBuildKeyValueList (
1773 IN CHAR8 *Data,
1774 IN UINT32 Len
1775 )
1776 {
1777 LIST_ENTRY *ListHead;
1778 ISCSI_KEY_VALUE_PAIR *KeyValuePair;
1779
1780 ListHead = AllocatePool (sizeof (LIST_ENTRY));
1781 if (ListHead == NULL) {
1782 return NULL;
1783 }
1784
1785 InitializeListHead (ListHead);
1786
1787 while (Len > 0) {
1788 KeyValuePair = AllocatePool (sizeof (ISCSI_KEY_VALUE_PAIR));
1789 if (KeyValuePair == NULL) {
1790 goto ON_ERROR;
1791 }
1792
1793 InitializeListHead (&KeyValuePair->List);
1794
1795 KeyValuePair->Key = Data;
1796
1797 while ((Len > 0) && (*Data != '=')) {
1798 Len--;
1799 Data++;
1800 }
1801
1802 if (*Data == '=') {
1803 *Data = '\0';
1804
1805 Data++;
1806 Len--;
1807 } else {
1808 FreePool (KeyValuePair);
1809 goto ON_ERROR;
1810 }
1811
1812 KeyValuePair->Value = Data;
1813
1814 InsertTailList (ListHead, &KeyValuePair->List);;
1815
1816 Data += AsciiStrLen (KeyValuePair->Value) + 1;
1817 Len -= (UINT32) AsciiStrLen (KeyValuePair->Value) + 1;
1818 }
1819
1820 return ListHead;
1821
1822 ON_ERROR:
1823
1824 IScsiFreeKeyValueList (ListHead);
1825
1826 return NULL;
1827 }
1828
1829
1830 /**
1831 Get the value string by the key name from the key-value list. If found,
1832 the key-value entry will be removed from the list.
1833
1834 @param[in, out] KeyValueList The key-value list.
1835 @param[in] Key The key name to find.
1836
1837 @return The value string.
1838 @retval NULL The key value pair cannot be found.
1839
1840 **/
1841 CHAR8 *
1842 IScsiGetValueByKeyFromList (
1843 IN OUT LIST_ENTRY *KeyValueList,
1844 IN CHAR8 *Key
1845 )
1846 {
1847 LIST_ENTRY *Entry;
1848 ISCSI_KEY_VALUE_PAIR *KeyValuePair;
1849 CHAR8 *Value;
1850
1851 Value = NULL;
1852
1853 NET_LIST_FOR_EACH (Entry, KeyValueList) {
1854 KeyValuePair = NET_LIST_USER_STRUCT (Entry, ISCSI_KEY_VALUE_PAIR, List);
1855
1856 if (AsciiStrCmp (KeyValuePair->Key, Key) == 0) {
1857 Value = KeyValuePair->Value;
1858
1859 RemoveEntryList (&KeyValuePair->List);
1860 FreePool (KeyValuePair);
1861 break;
1862 }
1863 }
1864
1865 return Value;
1866 }
1867
1868
1869 /**
1870 Free the key-value list.
1871
1872 @param[in] KeyValueList The key-value list.
1873
1874 **/
1875 VOID
1876 IScsiFreeKeyValueList (
1877 IN LIST_ENTRY *KeyValueList
1878 )
1879 {
1880 LIST_ENTRY *Entry;
1881 ISCSI_KEY_VALUE_PAIR *KeyValuePair;
1882
1883 while (!IsListEmpty (KeyValueList)) {
1884 Entry = NetListRemoveHead (KeyValueList);
1885 KeyValuePair = NET_LIST_USER_STRUCT (Entry, ISCSI_KEY_VALUE_PAIR, List);
1886
1887 FreePool (KeyValuePair);
1888 }
1889
1890 FreePool (KeyValueList);
1891 }
1892
1893
1894 /**
1895 Normalize the iSCSI name according to RFC.
1896
1897 @param[in, out] Name The iSCSI name.
1898 @param[in] Len Length of the iSCSI name.
1899
1900 @retval EFI_SUCCESS The iSCSI name is valid and normalized.
1901 @retval EFI_PROTOCOL_ERROR The iSCSI name is malformatted or not in the IQN format.
1902
1903 **/
1904 EFI_STATUS
1905 IScsiNormalizeName (
1906 IN OUT CHAR8 *Name,
1907 IN UINTN Len
1908 )
1909 {
1910 UINTN Index;
1911
1912 for (Index = 0; Index < Len; Index++) {
1913 if (NET_IS_UPPER_CASE_CHAR (Name[Index])) {
1914 //
1915 // Convert the upper-case characters to lower-case ones.
1916 //
1917 Name[Index] = (CHAR8) (Name[Index] - 'A' + 'a');
1918 }
1919
1920 if (!NET_IS_LOWER_CASE_CHAR (Name[Index]) &&
1921 !NET_IS_DIGIT (Name[Index]) &&
1922 (Name[Index] != '-') &&
1923 (Name[Index] != '.') &&
1924 (Name[Index] != ':')
1925 ) {
1926 //
1927 // ASCII dash, dot, colon lower-case characters and digit characters
1928 // are allowed.
1929 //
1930 return EFI_PROTOCOL_ERROR;
1931 }
1932 }
1933
1934 if ((Len < 4) || (CompareMem (Name, "iqn.", 4) != 0)) {
1935 //
1936 // Only IQN format is accepted now.
1937 //
1938 return EFI_PROTOCOL_ERROR;
1939 }
1940
1941 return EFI_SUCCESS;
1942 }
1943
1944
1945 /**
1946 Create an iSCSI task control block.
1947
1948 @param[in] Conn The connection on which the task control block will be created.
1949 @param[out] Tcb The newly created task control block.
1950
1951 @retval EFI_SUCCESS The task control block is created.
1952 @retval EFI_OUT_OF_RESOURCES Failed to allocate memory.
1953 @retval EFI_NOT_READY The target cannot accept new commands.
1954
1955 **/
1956 EFI_STATUS
1957 IScsiNewTcb (
1958 IN ISCSI_CONNECTION *Conn,
1959 OUT ISCSI_TCB **Tcb
1960 )
1961 {
1962 ISCSI_SESSION *Session;
1963 ISCSI_TCB *NewTcb;
1964
1965 ASSERT (Tcb != NULL);
1966
1967 Session = Conn->Session;
1968
1969 if (ISCSI_SEQ_GT (Session->CmdSN, Session->MaxCmdSN)) {
1970 return EFI_NOT_READY;
1971 }
1972
1973 NewTcb = AllocateZeroPool (sizeof (ISCSI_TCB));
1974 if (NewTcb == NULL) {
1975 return EFI_OUT_OF_RESOURCES;
1976 }
1977
1978 InitializeListHead (&NewTcb->Link);
1979
1980 NewTcb->SoFarInOrder = TRUE;
1981 NewTcb->InitiatorTaskTag = Session->InitiatorTaskTag;
1982 NewTcb->CmdSN = Session->CmdSN;
1983 NewTcb->Conn = Conn;
1984
1985 InsertTailList (&Session->TcbList, &NewTcb->Link);
1986
1987 //
1988 // Advance the initiator task tag.
1989 //
1990 Session->InitiatorTaskTag++;
1991 Session->CmdSN++;
1992
1993 *Tcb = NewTcb;
1994
1995 return EFI_SUCCESS;
1996 }
1997
1998
1999 /**
2000 Delete the tcb from the connection and destroy it.
2001
2002 @param[in] Tcb The tcb to delete.
2003
2004 **/
2005 VOID
2006 IScsiDelTcb (
2007 IN ISCSI_TCB *Tcb
2008 )
2009 {
2010 RemoveEntryList (&Tcb->Link);
2011
2012 FreePool (Tcb);
2013 }
2014
2015
2016 /**
2017 Find the task control block by the initator task tag.
2018
2019 @param[in] TcbList The tcb list.
2020 @param[in] InitiatorTaskTag The initiator task tag.
2021
2022 @return The task control block found.
2023 @retval NULL The task control block cannot be found.
2024
2025 **/
2026 ISCSI_TCB *
2027 IScsiFindTcbByITT (
2028 IN LIST_ENTRY *TcbList,
2029 IN UINT32 InitiatorTaskTag
2030 )
2031 {
2032 ISCSI_TCB *Tcb;
2033 LIST_ENTRY *Entry;
2034
2035 Tcb = NULL;
2036
2037 NET_LIST_FOR_EACH (Entry, TcbList) {
2038 Tcb = NET_LIST_USER_STRUCT (Entry, ISCSI_TCB, Link);
2039
2040 if (Tcb->InitiatorTaskTag == InitiatorTaskTag) {
2041 break;
2042 }
2043 }
2044
2045 return Tcb;
2046 }
2047
2048
2049 /**
2050 Create a data segment, pad it, and calculate the CRC if needed.
2051
2052 @param[in] Data The data to fill into the data segment.
2053 @param[in] Len Length of the data.
2054 @param[in] DataDigest Whether to calculate CRC for this data segment.
2055
2056 @return The net buffer wrapping the data segment.
2057
2058 **/
2059 NET_BUF *
2060 IScsiNewDataSegment (
2061 IN UINT8 *Data,
2062 IN UINT32 Len,
2063 IN BOOLEAN DataDigest
2064 )
2065 {
2066 NET_FRAGMENT Fragment[2];
2067 UINT32 FragmentCount;
2068 UINT32 PadLen;
2069 NET_BUF *DataSeg;
2070
2071 Fragment[0].Len = Len;
2072 Fragment[0].Bulk = Data;
2073
2074 PadLen = ISCSI_GET_PAD_LEN (Len);
2075 if (PadLen != 0) {
2076 Fragment[1].Len = PadLen;
2077 Fragment[1].Bulk = (UINT8 *) &mDataSegPad;
2078
2079 FragmentCount = 2;
2080 } else {
2081 FragmentCount = 1;
2082 }
2083
2084 DataSeg = NetbufFromExt (&Fragment[0], FragmentCount, 0, 0, IScsiNbufExtFree, NULL);
2085
2086 return DataSeg;
2087 }
2088
2089
2090 /**
2091 Create a iSCSI SCSI command PDU to encapsulate the command issued
2092 by SCSI through the EXT SCSI PASS THRU Protocol.
2093
2094 @param[in] Packet The EXT SCSI PASS THRU request packet containing the SCSI command.
2095 @param[in] Lun The LUN.
2096 @param[in] Tcb The tcb assocated with this SCSI command.
2097
2098 @return The created iSCSI SCSI command PDU.
2099 @retval NULL Other errors as indicated.
2100
2101 **/
2102 NET_BUF *
2103 IScsiNewScsiCmdPdu (
2104 IN EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET *Packet,
2105 IN UINT64 Lun,
2106 IN ISCSI_TCB *Tcb
2107 )
2108 {
2109 LIST_ENTRY *NbufList;
2110 NET_BUF *Pdu;
2111 NET_BUF *PduHeader;
2112 NET_BUF *DataSeg;
2113 SCSI_COMMAND *ScsiCmd;
2114 UINT8 AHSLength;
2115 UINT32 Length;
2116 ISCSI_ADDITIONAL_HEADER *Header;
2117 ISCSI_BI_EXP_READ_DATA_LEN_AHS *BiExpReadDataLenAHS;
2118 ISCSI_SESSION *Session;
2119 UINT32 ImmediateDataLen;
2120
2121 AHSLength = 0;
2122
2123 if (Packet->DataDirection == DataBi) {
2124 //
2125 // Bidirectional Read/Write command, the bidirectional expected
2126 // read data length AHS is required.
2127 //
2128 AHSLength += sizeof (ISCSI_BI_EXP_READ_DATA_LEN_AHS);
2129 }
2130
2131 if (Packet->CdbLength > 16) {
2132 //
2133 // The CDB exceeds 16 bytes. An extended CDB AHS is required.
2134 //
2135 AHSLength = (UINT8) (AHSLength + ISCSI_ROUNDUP (Packet->CdbLength - 16) + sizeof (ISCSI_ADDITIONAL_HEADER));
2136 }
2137
2138 Length = sizeof (SCSI_COMMAND) + AHSLength;
2139 PduHeader = NetbufAlloc (Length);
2140 if (PduHeader == NULL) {
2141 return NULL;
2142 }
2143
2144 ScsiCmd = (SCSI_COMMAND *) NetbufAllocSpace (PduHeader, Length, NET_BUF_TAIL);
2145 if (ScsiCmd == NULL) {
2146 NetbufFree (PduHeader);
2147 return NULL;
2148 }
2149 Header = (ISCSI_ADDITIONAL_HEADER *) (ScsiCmd + 1);
2150
2151 ZeroMem (ScsiCmd, Length);
2152
2153 ISCSI_SET_OPCODE (ScsiCmd, ISCSI_OPCODE_SCSI_CMD, 0);
2154 ISCSI_SET_FLAG (ScsiCmd, ISCSI_TASK_ATTR_SIMPLE);
2155
2156 //
2157 // Set the READ/WRITE flags according to the IO type of this request.
2158 //
2159 switch (Packet->DataDirection) {
2160 case DataIn:
2161 ISCSI_SET_FLAG (ScsiCmd, SCSI_CMD_PDU_FLAG_READ);
2162 ScsiCmd->ExpDataXferLength = NTOHL (Packet->InTransferLength);
2163 break;
2164
2165 case DataOut:
2166 ISCSI_SET_FLAG (ScsiCmd, SCSI_CMD_PDU_FLAG_WRITE);
2167 ScsiCmd->ExpDataXferLength = NTOHL (Packet->OutTransferLength);
2168 break;
2169
2170 case DataBi:
2171 ISCSI_SET_FLAG (ScsiCmd, SCSI_CMD_PDU_FLAG_READ | SCSI_CMD_PDU_FLAG_WRITE);
2172 ScsiCmd->ExpDataXferLength = NTOHL (Packet->OutTransferLength);
2173
2174 //
2175 // Fill the bidirectional expected read data length AHS.
2176 //
2177 BiExpReadDataLenAHS = (ISCSI_BI_EXP_READ_DATA_LEN_AHS *) Header;
2178 Header = (ISCSI_ADDITIONAL_HEADER *) (BiExpReadDataLenAHS + 1);
2179
2180 BiExpReadDataLenAHS->Length = NTOHS (5);
2181 BiExpReadDataLenAHS->Type = ISCSI_AHS_TYPE_BI_EXP_READ_DATA_LEN;
2182 BiExpReadDataLenAHS->ExpReadDataLength = NTOHL (Packet->InTransferLength);
2183
2184 break;
2185 }
2186
2187 ScsiCmd->TotalAHSLength = AHSLength;
2188 CopyMem (ScsiCmd->Lun, &Lun, sizeof (ScsiCmd->Lun));
2189 ScsiCmd->InitiatorTaskTag = NTOHL (Tcb->InitiatorTaskTag);
2190 ScsiCmd->CmdSN = NTOHL (Tcb->CmdSN);
2191 ScsiCmd->ExpStatSN = NTOHL (Tcb->Conn->ExpStatSN);
2192
2193 CopyMem (ScsiCmd->Cdb, Packet->Cdb, sizeof (ScsiCmd->Cdb));
2194
2195 if (Packet->CdbLength > 16) {
2196 Header->Length = NTOHS ((UINT16) (Packet->CdbLength - 15));
2197 Header->Type = ISCSI_AHS_TYPE_EXT_CDB;
2198
2199 CopyMem (Header + 1, (UINT8 *) Packet->Cdb + 16, Packet->CdbLength - 16);
2200 }
2201
2202 Pdu = PduHeader;
2203 Session = Tcb->Conn->Session;
2204 ImmediateDataLen = 0;
2205
2206 if (Session->ImmediateData && (Packet->OutTransferLength != 0)) {
2207 //
2208 // Send immediate data in this SCSI Command PDU. The length of the immeidate
2209 // data is the minimum of FirstBurstLength, the data length to be xfered, and
2210 // the MaxRecvdataSegmentLength on this connection.
2211 //
2212 ImmediateDataLen = MIN (Session->FirstBurstLength, Packet->OutTransferLength);
2213 ImmediateDataLen = MIN (ImmediateDataLen, Tcb->Conn->MaxRecvDataSegmentLength);
2214
2215 //
2216 // Update the data segment length in the PDU header.
2217 //
2218 ISCSI_SET_DATASEG_LEN (ScsiCmd, ImmediateDataLen);
2219
2220 //
2221 // Create the data segment.
2222 //
2223 DataSeg = IScsiNewDataSegment ((UINT8 *) Packet->OutDataBuffer, ImmediateDataLen, FALSE);
2224 if (DataSeg == NULL) {
2225 NetbufFree (PduHeader);
2226 Pdu = NULL;
2227 goto ON_EXIT;
2228 }
2229
2230 NbufList = AllocatePool (sizeof (LIST_ENTRY));
2231 if (NbufList == NULL) {
2232 NetbufFree (PduHeader);
2233 NetbufFree (DataSeg);
2234
2235 Pdu = NULL;
2236 goto ON_EXIT;
2237 }
2238
2239 InitializeListHead (NbufList);
2240 InsertTailList (NbufList, &PduHeader->List);
2241 InsertTailList (NbufList, &DataSeg->List);
2242
2243 Pdu = NetbufFromBufList (NbufList, 0, 0, IScsiFreeNbufList, NbufList);
2244 if (Pdu == NULL) {
2245 IScsiFreeNbufList (NbufList);
2246 }
2247 }
2248
2249 if (Session->InitialR2T ||
2250 (ImmediateDataLen == Session->FirstBurstLength) ||
2251 (ImmediateDataLen == Packet->OutTransferLength)
2252 ) {
2253 //
2254 // Unsolicited data out sequence is not allowed,
2255 // or FirstBustLength data is already sent out by immediate data,
2256 // or all the OUT data accompany this SCSI packet are sent as
2257 // immediate data. The final flag should be set on this SCSI Command
2258 // PDU.
2259 //
2260 ISCSI_SET_FLAG (ScsiCmd, ISCSI_BHS_FLAG_FINAL);
2261 }
2262
2263 ON_EXIT:
2264
2265 return Pdu;
2266 }
2267
2268
2269 /**
2270 Create a new iSCSI SCSI Data Out PDU.
2271
2272 @param[in] Data The data to put into the Data Out PDU.
2273 @param[in] Len Length of the data.
2274 @param[in] DataSN The DataSN of the Data Out PDU.
2275 @param[in] Tcb The task control block of this Data Out PDU.
2276 @param[in] Lun The LUN.
2277
2278 @return The net buffer wrapping the Data Out PDU.
2279 @retval NULL Other errors as indicated.
2280
2281 **/
2282 NET_BUF *
2283 IScsiNewDataOutPdu (
2284 IN UINT8 *Data,
2285 IN UINT32 Len,
2286 IN UINT32 DataSN,
2287 IN ISCSI_TCB *Tcb,
2288 IN UINT64 Lun
2289 )
2290 {
2291 LIST_ENTRY *NbufList;
2292 NET_BUF *PduHdr;
2293 NET_BUF *DataSeg;
2294 NET_BUF *Pdu;
2295 ISCSI_SCSI_DATA_OUT *DataOutHdr;
2296 ISCSI_XFER_CONTEXT *XferContext;
2297
2298 NbufList = AllocatePool (sizeof (LIST_ENTRY));
2299 if (NbufList == NULL) {
2300 return NULL;
2301 }
2302
2303 InitializeListHead (NbufList);
2304
2305 //
2306 // Allocate memory for the BHS.
2307 //
2308 PduHdr = NetbufAlloc (sizeof (ISCSI_SCSI_DATA_OUT));
2309 if (PduHdr == NULL) {
2310 FreePool (NbufList);
2311 return NULL;
2312 }
2313 //
2314 // Insert the BHS into the buffer list.
2315 //
2316 InsertTailList (NbufList, &PduHdr->List);
2317
2318 DataOutHdr = (ISCSI_SCSI_DATA_OUT *) NetbufAllocSpace (PduHdr, sizeof (ISCSI_SCSI_DATA_OUT), NET_BUF_TAIL);
2319 ASSERT (DataOutHdr != NULL);
2320 XferContext = &Tcb->XferContext;
2321
2322 ZeroMem (DataOutHdr, sizeof (ISCSI_SCSI_DATA_OUT));
2323
2324 //
2325 // Set the flags and fields of the Data Out PDU BHS.
2326 //
2327 ISCSI_SET_OPCODE (DataOutHdr, ISCSI_OPCODE_SCSI_DATA_OUT, 0);
2328 ISCSI_SET_DATASEG_LEN (DataOutHdr, Len);
2329
2330 DataOutHdr->InitiatorTaskTag = HTONL (Tcb->InitiatorTaskTag);
2331 DataOutHdr->TargetTransferTag = HTONL (XferContext->TargetTransferTag);
2332 DataOutHdr->ExpStatSN = HTONL (Tcb->Conn->ExpStatSN);
2333 DataOutHdr->DataSN = HTONL (DataSN);
2334 DataOutHdr->BufferOffset = HTONL (XferContext->Offset);
2335
2336 if (XferContext->TargetTransferTag != ISCSI_RESERVED_TAG) {
2337 CopyMem (&DataOutHdr->Lun, &Lun, sizeof (DataOutHdr->Lun));
2338 }
2339 //
2340 // Build the data segment for this Data Out PDU.
2341 //
2342 DataSeg = IScsiNewDataSegment (Data, Len, FALSE);
2343 if (DataSeg == NULL) {
2344 IScsiFreeNbufList (NbufList);
2345 return NULL;
2346 }
2347 //
2348 // Put the data segment into the buffer list and combine it with the BHS
2349 // into a full Data Out PDU.
2350 //
2351 InsertTailList (NbufList, &DataSeg->List);
2352 Pdu = NetbufFromBufList (NbufList, 0, 0, IScsiFreeNbufList, NbufList);
2353 if (Pdu == NULL) {
2354 IScsiFreeNbufList (NbufList);
2355 }
2356
2357 return Pdu;
2358 }
2359
2360
2361 /**
2362 Generate a consecutive sequence of iSCSI SCSI Data Out PDUs.
2363
2364 @param[in] Data The data which will be carried by the sequence of iSCSI SCSI Data Out PDUs.
2365 @param[in] Tcb The task control block of the data to send out.
2366 @param[in] Lun The LUN the data will be sent to.
2367
2368 @return A list of net buffers with each of them wrapping an iSCSI SCSI Data Out PDU.
2369 @retval NULL Other errors as indicated.
2370
2371 **/
2372 LIST_ENTRY *
2373 IScsiGenerateDataOutPduSequence (
2374 IN UINT8 *Data,
2375 IN ISCSI_TCB *Tcb,
2376 IN UINT64 Lun
2377 )
2378 {
2379 LIST_ENTRY *PduList;
2380 UINT32 DataSN;
2381 UINT32 DataLen;
2382 NET_BUF *DataOutPdu;
2383 ISCSI_CONNECTION *Conn;
2384 ISCSI_XFER_CONTEXT *XferContext;
2385 UINT8 *DataOutPacket;
2386
2387 PduList = AllocatePool (sizeof (LIST_ENTRY));
2388 if (PduList == NULL) {
2389 return NULL;
2390 }
2391
2392 InitializeListHead (PduList);
2393
2394 DataSN = 0;
2395 Conn = Tcb->Conn;
2396 DataOutPdu = NULL;
2397 XferContext = &Tcb->XferContext;
2398
2399 while (XferContext->DesiredLength > 0) {
2400 //
2401 // Determine the length of data this Data Out PDU can carry.
2402 //
2403 DataLen = MIN (XferContext->DesiredLength, Conn->MaxRecvDataSegmentLength);
2404
2405 //
2406 // Create a Data Out PDU.
2407 //
2408 DataOutPdu = IScsiNewDataOutPdu (Data, DataLen, DataSN, Tcb, Lun);
2409 if (DataOutPdu == NULL) {
2410 IScsiFreeNbufList (PduList);
2411 PduList = NULL;
2412
2413 goto ON_EXIT;
2414 }
2415
2416 InsertTailList (PduList, &DataOutPdu->List);
2417
2418 //
2419 // Update the context and DataSN.
2420 //
2421 Data += DataLen;
2422 XferContext->Offset += DataLen;
2423 XferContext->DesiredLength -= DataLen;
2424 DataSN++;
2425 }
2426 //
2427 // Set the F bit for the last data out PDU in this sequence.
2428 //
2429 DataOutPacket = NetbufGetByte (DataOutPdu, 0, NULL);
2430 if (DataOutPacket == NULL) {
2431 IScsiFreeNbufList (PduList);
2432 PduList = NULL;
2433 goto ON_EXIT;
2434 }
2435
2436 ISCSI_SET_FLAG (DataOutPacket, ISCSI_BHS_FLAG_FINAL);
2437
2438 ON_EXIT:
2439
2440 return PduList;
2441 }
2442
2443 /**
2444 Send the Data in a sequence of Data Out PDUs one by one.
2445
2446 @param[in] Data The data to carry by Data Out PDUs.
2447 @param[in] Lun The LUN the data will be sent to.
2448 @param[in] Tcb The task control block.
2449
2450 @retval EFI_SUCCES The data is sent out to the LUN.
2451 @retval EFI_OUT_OF_RESOURCES Failed to allocate memory.
2452 @retval Others Other errors as indicated.
2453
2454 **/
2455 EFI_STATUS
2456 IScsiSendDataOutPduSequence (
2457 IN UINT8 *Data,
2458 IN UINT64 Lun,
2459 IN ISCSI_TCB *Tcb
2460 )
2461 {
2462 LIST_ENTRY *DataOutPduList;
2463 LIST_ENTRY *Entry;
2464 NET_BUF *Pdu;
2465 EFI_STATUS Status;
2466
2467 //
2468 // Generate the Data Out PDU sequence.
2469 //
2470 DataOutPduList = IScsiGenerateDataOutPduSequence (Data, Tcb, Lun);
2471 if (DataOutPduList == NULL) {
2472 return EFI_OUT_OF_RESOURCES;
2473 }
2474
2475 Status = EFI_SUCCESS;
2476
2477 //
2478 // Send the Data Out PDU's one by one.
2479 //
2480 NET_LIST_FOR_EACH (Entry, DataOutPduList) {
2481 Pdu = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);
2482
2483 Status = TcpIoTransmit (&Tcb->Conn->TcpIo, Pdu);
2484
2485 if (EFI_ERROR (Status)) {
2486 break;
2487 }
2488 }
2489
2490 IScsiFreeNbufList (DataOutPduList);
2491
2492 return Status;
2493 }
2494
2495
2496 /**
2497 Process the received iSCSI SCSI Data In PDU.
2498
2499 @param[in] Pdu The Data In PDU received.
2500 @param[in] Tcb The task control block.
2501 @param[in, out] Packet The EXT SCSI PASS THRU request packet.
2502
2503 @retval EFI_SUCCES The check on the Data IN PDU is passed and some update
2504 actions are taken.
2505 @retval EFI_PROTOCOL_ERROR Some kind of iSCSI protocol errror occurred.
2506 @retval EFI_BAD_BUFFER_SIZEE The buffer was not the proper size for the request.
2507 @retval Others Other errors as indicated.
2508
2509 **/
2510 EFI_STATUS
2511 IScsiOnDataInRcvd (
2512 IN NET_BUF *Pdu,
2513 IN ISCSI_TCB *Tcb,
2514 IN OUT EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET *Packet
2515 )
2516 {
2517 ISCSI_SCSI_DATA_IN *DataInHdr;
2518 EFI_STATUS Status;
2519
2520 DataInHdr = (ISCSI_SCSI_DATA_IN *) NetbufGetByte (Pdu, 0, NULL);
2521 if (DataInHdr == NULL) {
2522 return EFI_PROTOCOL_ERROR;
2523 }
2524
2525 DataInHdr->InitiatorTaskTag = NTOHL (DataInHdr->InitiatorTaskTag);
2526 DataInHdr->ExpCmdSN = NTOHL (DataInHdr->ExpCmdSN);
2527 DataInHdr->MaxCmdSN = NTOHL (DataInHdr->MaxCmdSN);
2528 DataInHdr->DataSN = NTOHL (DataInHdr->DataSN);
2529
2530 //
2531 // Check the DataSN.
2532 //
2533 Status = IScsiCheckSN (&Tcb->ExpDataSN, DataInHdr->DataSN);
2534 if (EFI_ERROR (Status)) {
2535 return Status;
2536 }
2537
2538 if (DataInHdr->InitiatorTaskTag != Tcb->InitiatorTaskTag) {
2539 return EFI_PROTOCOL_ERROR;
2540 }
2541 //
2542 // Update the command related sequence numbers.
2543 //
2544 IScsiUpdateCmdSN (Tcb->Conn->Session, DataInHdr->MaxCmdSN, DataInHdr->ExpCmdSN);
2545
2546 if (ISCSI_FLAG_ON (DataInHdr, SCSI_DATA_IN_PDU_FLAG_STATUS_VALID)) {
2547 if (!ISCSI_FLAG_ON (DataInHdr, ISCSI_BHS_FLAG_FINAL)) {
2548 //
2549 // The S bit is on but the F bit is off.
2550 //
2551 return EFI_PROTOCOL_ERROR;
2552 }
2553
2554 Tcb->StatusXferd = TRUE;
2555
2556 if (ISCSI_FLAG_ON (DataInHdr, SCSI_DATA_IN_PDU_FLAG_OVERFLOW | SCSI_DATA_IN_PDU_FLAG_UNDERFLOW)) {
2557 //
2558 // Underflow and Overflow are mutual flags.
2559 //
2560 return EFI_PROTOCOL_ERROR;
2561 }
2562 //
2563 // S bit is on, the StatSN is valid.
2564 //
2565 Status = IScsiCheckSN (&Tcb->Conn->ExpStatSN, NTOHL (DataInHdr->StatSN));
2566 if (EFI_ERROR (Status)) {
2567 return Status;
2568 }
2569
2570 Packet->HostAdapterStatus = 0;
2571 Packet->TargetStatus = DataInHdr->Status;
2572
2573 if (ISCSI_FLAG_ON (DataInHdr, SCSI_RSP_PDU_FLAG_OVERFLOW)) {
2574 Packet->InTransferLength += NTOHL (DataInHdr->ResidualCount);
2575 Status = EFI_BAD_BUFFER_SIZE;
2576 }
2577
2578 if (ISCSI_FLAG_ON (DataInHdr, SCSI_RSP_PDU_FLAG_UNDERFLOW)) {
2579 Packet->InTransferLength -= NTOHL (DataInHdr->ResidualCount);
2580 }
2581 }
2582
2583 return Status;
2584 }
2585
2586
2587 /**
2588 Process the received iSCSI R2T PDU.
2589
2590 @param[in] Pdu The R2T PDU received.
2591 @param[in] Tcb The task control block.
2592 @param[in] Lun The Lun.
2593 @param[in, out] Packet The EXT SCSI PASS THRU request packet.
2594
2595 @retval EFI_SUCCES The R2T PDU is valid and the solicited data is sent out.
2596 @retval EFI_PROTOCOL_ERROR Some kind of iSCSI protocol errror occurred.
2597 @retval Others Other errors as indicated.
2598
2599 **/
2600 EFI_STATUS
2601 IScsiOnR2TRcvd (
2602 IN NET_BUF *Pdu,
2603 IN ISCSI_TCB *Tcb,
2604 IN UINT64 Lun,
2605 IN OUT EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET *Packet
2606 )
2607 {
2608 ISCSI_READY_TO_TRANSFER *R2THdr;
2609 EFI_STATUS Status;
2610 ISCSI_XFER_CONTEXT *XferContext;
2611 UINT8 *Data;
2612
2613 R2THdr = (ISCSI_READY_TO_TRANSFER *) NetbufGetByte (Pdu, 0, NULL);
2614 if (R2THdr == NULL) {
2615 return EFI_PROTOCOL_ERROR;
2616 }
2617
2618 R2THdr->InitiatorTaskTag = NTOHL (R2THdr->InitiatorTaskTag);
2619 R2THdr->TargetTransferTag = NTOHL (R2THdr->TargetTransferTag);
2620 R2THdr->StatSN = NTOHL (R2THdr->StatSN);
2621 R2THdr->R2TSeqNum = NTOHL (R2THdr->R2TSeqNum);
2622 R2THdr->BufferOffset = NTOHL (R2THdr->BufferOffset);
2623 R2THdr->DesiredDataTransferLength = NTOHL (R2THdr->DesiredDataTransferLength);
2624
2625 if ((R2THdr->InitiatorTaskTag != Tcb->InitiatorTaskTag) || !ISCSI_SEQ_EQ (R2THdr->StatSN, Tcb->Conn->ExpStatSN)) {
2626 return EFI_PROTOCOL_ERROR;;
2627 }
2628 //
2629 // Check the sequence number.
2630 //
2631 Status = IScsiCheckSN (&Tcb->ExpDataSN, R2THdr->R2TSeqNum);
2632 if (EFI_ERROR (Status)) {
2633 return Status;
2634 }
2635
2636 XferContext = &Tcb->XferContext;
2637 XferContext->TargetTransferTag = R2THdr->TargetTransferTag;
2638 XferContext->Offset = R2THdr->BufferOffset;
2639 XferContext->DesiredLength = R2THdr->DesiredDataTransferLength;
2640
2641 if (((XferContext->Offset + XferContext->DesiredLength) > Packet->OutTransferLength) ||
2642 (XferContext->DesiredLength > Tcb->Conn->Session->MaxBurstLength)
2643 ) {
2644 return EFI_PROTOCOL_ERROR;
2645 }
2646 //
2647 // Send the data solicited by this R2T.
2648 //
2649 Data = (UINT8 *) Packet->OutDataBuffer + XferContext->Offset;
2650 Status = IScsiSendDataOutPduSequence (Data, Lun, Tcb);
2651
2652 return Status;
2653 }
2654
2655
2656 /**
2657 Process the received iSCSI SCSI Response PDU.
2658
2659 @param[in] Pdu The Response PDU received.
2660 @param[in] Tcb The task control block.
2661 @param[in, out] Packet The EXT SCSI PASS THRU request packet.
2662
2663 @retval EFI_SUCCES The Response PDU is processed.
2664 @retval EFI_PROTOCOL_ERROR Some kind of iSCSI protocol errror occurred.
2665 @retval EFI_BAD_BUFFER_SIZEE The buffer was not the proper size for the request.
2666 @retval Others Other errors as indicated.
2667
2668 **/
2669 EFI_STATUS
2670 IScsiOnScsiRspRcvd (
2671 IN NET_BUF *Pdu,
2672 IN ISCSI_TCB *Tcb,
2673 IN OUT EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET *Packet
2674 )
2675 {
2676 SCSI_RESPONSE *ScsiRspHdr;
2677 ISCSI_SENSE_DATA *SenseData;
2678 EFI_STATUS Status;
2679 UINT32 DataSegLen;
2680
2681 ScsiRspHdr = (SCSI_RESPONSE *) NetbufGetByte (Pdu, 0, NULL);
2682 if (ScsiRspHdr == NULL) {
2683 return EFI_PROTOCOL_ERROR;
2684 }
2685
2686 ScsiRspHdr->InitiatorTaskTag = NTOHL (ScsiRspHdr->InitiatorTaskTag);
2687 if (ScsiRspHdr->InitiatorTaskTag != Tcb->InitiatorTaskTag) {
2688 return EFI_PROTOCOL_ERROR;
2689 }
2690
2691 ScsiRspHdr->StatSN = NTOHL (ScsiRspHdr->StatSN);
2692
2693 Status = IScsiCheckSN (&Tcb->Conn->ExpStatSN, ScsiRspHdr->StatSN);
2694 if (EFI_ERROR (Status)) {
2695 return Status;
2696 }
2697
2698 ScsiRspHdr->MaxCmdSN = NTOHL (ScsiRspHdr->MaxCmdSN);
2699 ScsiRspHdr->ExpCmdSN = NTOHL (ScsiRspHdr->ExpCmdSN);
2700 IScsiUpdateCmdSN (Tcb->Conn->Session, ScsiRspHdr->MaxCmdSN, ScsiRspHdr->ExpCmdSN);
2701
2702 Tcb->StatusXferd = TRUE;
2703
2704 Packet->HostAdapterStatus = ScsiRspHdr->Response;
2705 if (Packet->HostAdapterStatus != ISCSI_SERVICE_RSP_COMMAND_COMPLETE_AT_TARGET) {
2706 return EFI_SUCCESS;
2707 }
2708
2709 Packet->TargetStatus = ScsiRspHdr->Status;
2710
2711 if (ISCSI_FLAG_ON (ScsiRspHdr, SCSI_RSP_PDU_FLAG_BI_READ_OVERFLOW | SCSI_RSP_PDU_FLAG_BI_READ_UNDERFLOW) ||
2712 ISCSI_FLAG_ON (ScsiRspHdr, SCSI_RSP_PDU_FLAG_OVERFLOW | SCSI_RSP_PDU_FLAG_UNDERFLOW)
2713 ) {
2714 return EFI_PROTOCOL_ERROR;
2715 }
2716
2717 if (ISCSI_FLAG_ON (ScsiRspHdr, SCSI_RSP_PDU_FLAG_BI_READ_OVERFLOW)) {
2718 Packet->InTransferLength += NTOHL (ScsiRspHdr->BiReadResidualCount);
2719 Status = EFI_BAD_BUFFER_SIZE;
2720 }
2721
2722 if (ISCSI_FLAG_ON (ScsiRspHdr, SCSI_RSP_PDU_FLAG_BI_READ_UNDERFLOW)) {
2723 Packet->InTransferLength -= NTOHL (ScsiRspHdr->BiReadResidualCount);
2724 }
2725
2726 if (ISCSI_FLAG_ON (ScsiRspHdr, SCSI_RSP_PDU_FLAG_OVERFLOW)) {
2727 if (Packet->DataDirection == DataIn) {
2728 Packet->InTransferLength += NTOHL (ScsiRspHdr->ResidualCount);
2729 } else {
2730 Packet->OutTransferLength += NTOHL (ScsiRspHdr->ResidualCount);
2731 }
2732
2733 Status = EFI_BAD_BUFFER_SIZE;
2734 }
2735
2736 if (ISCSI_FLAG_ON (ScsiRspHdr, SCSI_RSP_PDU_FLAG_UNDERFLOW)) {
2737 if (Packet->DataDirection == DataIn) {
2738 Packet->InTransferLength -= NTOHL (ScsiRspHdr->ResidualCount);
2739 } else {
2740 Packet->OutTransferLength -= NTOHL (ScsiRspHdr->ResidualCount);
2741 }
2742 }
2743
2744 DataSegLen = ISCSI_GET_DATASEG_LEN (ScsiRspHdr);
2745 if (DataSegLen != 0) {
2746 SenseData = (ISCSI_SENSE_DATA *) NetbufGetByte (Pdu, sizeof (SCSI_RESPONSE), NULL);
2747 if (SenseData == NULL) {
2748 return EFI_PROTOCOL_ERROR;
2749 }
2750
2751 SenseData->Length = NTOHS (SenseData->Length);
2752
2753 Packet->SenseDataLength = (UINT8) MIN (SenseData->Length, Packet->SenseDataLength);
2754 if (Packet->SenseDataLength != 0) {
2755 CopyMem (Packet->SenseData, &SenseData->Data[0], Packet->SenseDataLength);
2756 }
2757 } else {
2758 Packet->SenseDataLength = 0;
2759 }
2760
2761 return Status;
2762 }
2763
2764
2765 /**
2766 Process the received NOP In PDU.
2767
2768 @param[in] Pdu The NOP In PDU received.
2769 @param[in] Tcb The task control block.
2770
2771 @retval EFI_SUCCES The NOP In PDU is processed and the related sequence
2772 numbers are updated.
2773 @retval EFI_PROTOCOL_ERROR Some kind of iSCSI protocol errror occurred.
2774
2775 **/
2776 EFI_STATUS
2777 IScsiOnNopInRcvd (
2778 IN NET_BUF *Pdu,
2779 IN ISCSI_TCB *Tcb
2780 )
2781 {
2782 ISCSI_NOP_IN *NopInHdr;
2783 EFI_STATUS Status;
2784
2785 NopInHdr = (ISCSI_NOP_IN *) NetbufGetByte (Pdu, 0, NULL);
2786 if (NopInHdr == NULL) {
2787 return EFI_PROTOCOL_ERROR;
2788 }
2789
2790 NopInHdr->StatSN = NTOHL (NopInHdr->StatSN);
2791 NopInHdr->ExpCmdSN = NTOHL (NopInHdr->ExpCmdSN);
2792 NopInHdr->MaxCmdSN = NTOHL (NopInHdr->MaxCmdSN);
2793
2794 if (NopInHdr->InitiatorTaskTag == ISCSI_RESERVED_TAG) {
2795 if (NopInHdr->StatSN != Tcb->Conn->ExpStatSN) {
2796 return EFI_PROTOCOL_ERROR;
2797 }
2798 } else {
2799 Status = IScsiCheckSN (&Tcb->Conn->ExpStatSN, NopInHdr->StatSN);
2800 if (EFI_ERROR (Status)) {
2801 return Status;
2802 }
2803 }
2804
2805 IScsiUpdateCmdSN (Tcb->Conn->Session, NopInHdr->MaxCmdSN, NopInHdr->ExpCmdSN);
2806
2807 return EFI_SUCCESS;
2808 }
2809
2810
2811 /**
2812 Execute the SCSI command issued through the EXT SCSI PASS THRU protocol.
2813
2814 @param[in] PassThru The EXT SCSI PASS THRU protocol.
2815 @param[in] Target The target ID.
2816 @param[in] Lun The LUN.
2817 @param[in, out] Packet The request packet containing IO request, SCSI command
2818 buffer and buffers to read/write.
2819
2820 @retval EFI_SUCCES The SCSI command is executed and the result is updated to
2821 the Packet.
2822 @retval EFI_DEVICE_ERROR Session state was not as required.
2823 @retval EFI_OUT_OF_RESOURCES Failed to allocate memory.
2824 @retval EFI_PROTOCOL_ERROR There is no such data in the net buffer.
2825 @retval EFI_NOT_READY The target can not accept new commands.
2826 @retval Others Other errors as indicated.
2827
2828 **/
2829 EFI_STATUS
2830 IScsiExecuteScsiCommand (
2831 IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL *PassThru,
2832 IN UINT8 *Target,
2833 IN UINT64 Lun,
2834 IN OUT EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET *Packet
2835 )
2836 {
2837 EFI_STATUS Status;
2838 ISCSI_DRIVER_DATA *Private;
2839 ISCSI_SESSION *Session;
2840 EFI_EVENT TimeoutEvent;
2841 ISCSI_CONNECTION *Conn;
2842 ISCSI_TCB *Tcb;
2843 NET_BUF *Pdu;
2844 ISCSI_XFER_CONTEXT *XferContext;
2845 UINT8 *Data;
2846 ISCSI_IN_BUFFER_CONTEXT InBufferContext;
2847 UINT64 Timeout;
2848 UINT8 *PduHdr;
2849
2850 Private = ISCSI_DRIVER_DATA_FROM_EXT_SCSI_PASS_THRU (PassThru);
2851 Session = Private->Session;
2852 Status = EFI_SUCCESS;
2853 Tcb = NULL;
2854 TimeoutEvent = NULL;
2855 Timeout = 0;
2856
2857 if (Session->State != SESSION_STATE_LOGGED_IN) {
2858 Status = EFI_DEVICE_ERROR;
2859 goto ON_EXIT;
2860 }
2861
2862 Conn = NET_LIST_USER_STRUCT_S (
2863 Session->Conns.ForwardLink,
2864 ISCSI_CONNECTION,
2865 Link,
2866 ISCSI_CONNECTION_SIGNATURE
2867 );
2868
2869 if (Packet->Timeout != 0) {
2870 Timeout = MultU64x32 (Packet->Timeout, 4);
2871 }
2872
2873 Status = IScsiNewTcb (Conn, &Tcb);
2874 if (EFI_ERROR (Status)) {
2875 goto ON_EXIT;
2876 }
2877 //
2878 // Encapsulate the SCSI request packet into an iSCSI SCSI Command PDU.
2879 //
2880 Pdu = IScsiNewScsiCmdPdu (Packet, Lun, Tcb);
2881 if (Pdu == NULL) {
2882 Status = EFI_OUT_OF_RESOURCES;
2883 goto ON_EXIT;
2884 }
2885
2886 XferContext = &Tcb->XferContext;
2887 PduHdr = NetbufGetByte (Pdu, 0, NULL);
2888 if (PduHdr == NULL) {
2889 Status = EFI_PROTOCOL_ERROR;
2890 NetbufFree (Pdu);
2891 goto ON_EXIT;
2892 }
2893 XferContext->Offset = ISCSI_GET_DATASEG_LEN (PduHdr);
2894
2895 //
2896 // Transmit the SCSI Command PDU.
2897 //
2898 Status = TcpIoTransmit (&Conn->TcpIo, Pdu);
2899
2900 NetbufFree (Pdu);
2901
2902 if (EFI_ERROR (Status)) {
2903 goto ON_EXIT;
2904 }
2905
2906 if (!Session->InitialR2T &&
2907 (XferContext->Offset < Session->FirstBurstLength) &&
2908 (XferContext->Offset < Packet->OutTransferLength)
2909 ) {
2910 //
2911 // Unsolicited Data-Out sequence is allowed. There is remaining SCSI
2912 // OUT data, and the limit of FirstBurstLength is not reached.
2913 //
2914 XferContext->TargetTransferTag = ISCSI_RESERVED_TAG;
2915 XferContext->DesiredLength = MIN (
2916 Session->FirstBurstLength,
2917 Packet->OutTransferLength - XferContext->Offset
2918 );
2919
2920 Data = (UINT8 *) Packet->OutDataBuffer + XferContext->Offset;
2921 Status = IScsiSendDataOutPduSequence (Data, Lun, Tcb);
2922 if (EFI_ERROR (Status)) {
2923 goto ON_EXIT;
2924 }
2925 }
2926
2927 InBufferContext.InData = (UINT8 *) Packet->InDataBuffer;
2928 InBufferContext.InDataLen = Packet->InTransferLength;
2929
2930 while (!Tcb->StatusXferd) {
2931 //
2932 // Start the timeout timer.
2933 //
2934 if (Timeout != 0) {
2935 Status = gBS->SetTimer (Conn->TimeoutEvent, TimerRelative, Timeout);
2936 if (EFI_ERROR (Status)) {
2937 goto ON_EXIT;
2938 }
2939
2940 TimeoutEvent = Conn->TimeoutEvent;
2941 }
2942
2943 //
2944 // Try to receive PDU from target.
2945 //
2946 Status = IScsiReceivePdu (Conn, &Pdu, &InBufferContext, FALSE, FALSE, TimeoutEvent);
2947 if (EFI_ERROR (Status)) {
2948 goto ON_EXIT;
2949 }
2950
2951 PduHdr = NetbufGetByte (Pdu, 0, NULL);
2952 if (PduHdr == NULL) {
2953 Status = EFI_PROTOCOL_ERROR;
2954 NetbufFree (Pdu);
2955 goto ON_EXIT;
2956 }
2957 switch (ISCSI_GET_OPCODE (PduHdr)) {
2958 case ISCSI_OPCODE_SCSI_DATA_IN:
2959 Status = IScsiOnDataInRcvd (Pdu, Tcb, Packet);
2960 break;
2961
2962 case ISCSI_OPCODE_R2T:
2963 Status = IScsiOnR2TRcvd (Pdu, Tcb, Lun, Packet);
2964 break;
2965
2966 case ISCSI_OPCODE_SCSI_RSP:
2967 Status = IScsiOnScsiRspRcvd (Pdu, Tcb, Packet);
2968 break;
2969
2970 case ISCSI_OPCODE_NOP_IN:
2971 Status = IScsiOnNopInRcvd (Pdu, Tcb);
2972 break;
2973
2974 case ISCSI_OPCODE_VENDOR_T0:
2975 case ISCSI_OPCODE_VENDOR_T1:
2976 case ISCSI_OPCODE_VENDOR_T2:
2977 //
2978 // These messages are vendor specific. Skip them.
2979 //
2980 break;
2981
2982 default:
2983 Status = EFI_PROTOCOL_ERROR;
2984 break;
2985 }
2986
2987 NetbufFree (Pdu);
2988
2989 if (EFI_ERROR (Status)) {
2990 break;
2991 }
2992 }
2993
2994 ON_EXIT:
2995
2996 if (TimeoutEvent != NULL) {
2997 gBS->SetTimer (TimeoutEvent, TimerCancel, 0);
2998 }
2999
3000 if (Tcb != NULL) {
3001 IScsiDelTcb (Tcb);
3002 }
3003
3004 return Status;
3005 }
3006
3007
3008 /**
3009 Reinstate the session on some error.
3010
3011 @param[in] Session The iSCSI session
3012
3013 @retval EFI_SUCCESS The session is reinstated from some error.
3014 @retval Other Reinstatement failed.
3015
3016 **/
3017 EFI_STATUS
3018 IScsiSessionReinstatement (
3019 IN ISCSI_SESSION *Session
3020 )
3021 {
3022 EFI_STATUS Status;
3023
3024 ASSERT (Session->State != SESSION_STATE_FREE);
3025
3026 //
3027 // Abort the session and re-init it.
3028 //
3029 IScsiSessionAbort (Session);
3030 IScsiSessionInit (Session, TRUE);
3031
3032 //
3033 // Login again.
3034 //
3035 Status = IScsiSessionLogin (Session);
3036
3037 return Status;
3038 }
3039
3040
3041 /**
3042 Initialize some session parameters before login.
3043
3044 @param[in, out] Session The iSCSI session.
3045 @param[in] Recovery Whether the request is from a fresh new start or recovery.
3046
3047 **/
3048 VOID
3049 IScsiSessionInit (
3050 IN OUT ISCSI_SESSION *Session,
3051 IN BOOLEAN Recovery
3052 )
3053 {
3054 if (!Recovery) {
3055 Session->Signature = ISCSI_SESSION_SIGNATURE;
3056 Session->State = SESSION_STATE_FREE;
3057
3058 InitializeListHead (&Session->Conns);
3059 InitializeListHead (&Session->TcbList);
3060 }
3061
3062 Session->Tsih = 0;
3063
3064 Session->CmdSN = 1;
3065 Session->InitiatorTaskTag = 1;
3066 Session->NextCid = 1;
3067
3068 Session->TargetPortalGroupTag = 0;
3069 Session->MaxConnections = ISCSI_MAX_CONNS_PER_SESSION;
3070 Session->InitialR2T = FALSE;
3071 Session->ImmediateData = TRUE;
3072 Session->MaxBurstLength = 262144;
3073 Session->FirstBurstLength = MAX_RECV_DATA_SEG_LEN_IN_FFP;
3074 Session->DefaultTime2Wait = 2;
3075 Session->DefaultTime2Retain = 20;
3076 Session->MaxOutstandingR2T = DEFAULT_MAX_OUTSTANDING_R2T;
3077 Session->DataPDUInOrder = TRUE;
3078 Session->DataSequenceInOrder = TRUE;
3079 Session->ErrorRecoveryLevel = 0;
3080 }
3081
3082
3083 /**
3084 Abort the iSCSI session. That is, reset all the connection(s), and free the
3085 resources.
3086
3087 @param[in, out] Session The iSCSI session.
3088
3089 **/
3090 VOID
3091 IScsiSessionAbort (
3092 IN OUT ISCSI_SESSION *Session
3093 )
3094 {
3095 ISCSI_CONNECTION *Conn;
3096 EFI_GUID *ProtocolGuid;
3097
3098 if (Session->State != SESSION_STATE_LOGGED_IN) {
3099 return ;
3100 }
3101
3102 ASSERT (!IsListEmpty (&Session->Conns));
3103
3104 while (!IsListEmpty (&Session->Conns)) {
3105 Conn = NET_LIST_USER_STRUCT_S (
3106 Session->Conns.ForwardLink,
3107 ISCSI_CONNECTION,
3108 Link,
3109 ISCSI_CONNECTION_SIGNATURE
3110 );
3111 if (!Conn->Ipv6Flag) {
3112 ProtocolGuid = &gEfiTcp4ProtocolGuid;
3113 } else {
3114 ProtocolGuid = &gEfiTcp6ProtocolGuid;
3115 }
3116
3117 gBS->CloseProtocol (
3118 Conn->TcpIo.Handle,
3119 ProtocolGuid,
3120 Session->Private->Image,
3121 Session->Private->ExtScsiPassThruHandle
3122 );
3123
3124 IScsiConnReset (Conn);
3125
3126 IScsiDetatchConnection (Conn);
3127 IScsiDestroyConnection (Conn);
3128 }
3129
3130 Session->State = SESSION_STATE_FAILED;
3131
3132 return ;
3133 }
EFI Development Kit II mirror for PVE