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