VirtualBox

Ignore:
Timestamp:
Apr 14, 2023 3:17:44 PM (22 months ago)
Author:
vboxsync
Message:

Devices/EFI/FirmwareNew: Update to edk2-stable202302 and make it build, bugref:4643

Location:
trunk/src/VBox/Devices/EFI/FirmwareNew
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/EFI/FirmwareNew

  • trunk/src/VBox/Devices/EFI/FirmwareNew/NetworkPkg/IScsiDxe/IScsiProto.c

    r85718 r99404  
    99#include "IScsiImpl.h"
    1010
    11 UINT32 mDataSegPad = 0;
     11UINT32  mDataSegPad = 0;
    1212
    1313/**
    … …  
    4545}
    4646
    47 
    4847/**
    4948  Check the sequence number according to RFC3720.
    … …  
    8079  }
    8180}
    82 
    8381
    8482/**
    … …  
    9896{
    9997  if (ISCSI_SEQ_LT (MaxCmdSN, ExpCmdSN - 1)) {
    100     return ;
     98    return;
    10199  }
    102100
    … …  
    109107  }
    110108}
    111 
    112109
    113110/**
    … …  
    124121EFI_STATUS
    125122IScsiConnLogin (
    126   IN OUT ISCSI_CONNECTION    *Conn,
    127   IN     UINT16              Timeout
     123  IN OUT ISCSI_CONNECTION  *Conn,
     124  IN     UINT16            Timeout
    128125  )
    129126{
    … …  
    172169}
    173170
    174 
    175171/**
    176172  Reset the iSCSI connection.
    … …  
    187183}
    188184
    189 
    190185/**
    191186  Create a TCP connection for the iSCSI session.
    … …  
    198193ISCSI_CONNECTION *
    199194IScsiCreateConnection (
    200   IN ISCSI_SESSION      *Session
     195  IN ISCSI_SESSION  *Session
    201196  )
    202197{
    … …  
    246241  // Set the default connection-only parameters.
    247242  //
    248   Conn->MaxRecvDataSegmentLength  = DEFAULT_MAX_RECV_DATA_SEG_LEN;
    249   Conn->HeaderDigest              = IScsiDigestNone;
    250   Conn->DataDigest                = IScsiDigestNone;
     243  Conn->MaxRecvDataSegmentLength = DEFAULT_MAX_RECV_DATA_SEG_LEN;
     244  Conn->HeaderDigest             = IScsiDigestNone;
     245  Conn->DataDigest               = IScsiDigestNone;
    251246
    252247  if (NvData->DnsMode) {
    … …  
    260255    }
    261256
    262     if (EFI_ERROR(Status)) {
    263       DEBUG ((EFI_D_ERROR, "The configuration of Target address or DNS server address is invalid!\n"));
     257    if (EFI_ERROR (Status)) {
     258      DEBUG ((DEBUG_ERROR, "The configuration of Target address or DNS server address is invalid!\n"));
    264259      FreePool (Conn);
    265260      return NULL;
    … …  
    293288             Private->Image,
    294289             Private->Controller,
    295              (UINT8) (!Conn->Ipv6Flag ? TCP_VERSION_4: TCP_VERSION_6),
     290             (UINT8)(!Conn->Ipv6Flag ? TCP_VERSION_4 : TCP_VERSION_6),
    296291             &TcpIoConfig,
    297292             &Conn->TcpIo
    … …  
    305300  return Conn;
    306301}
    307 
    308302
    309303/**
    … …  
    382376
    383377  SubnetPrefixLength = 0;
    384   RouteEntry = Ip6ModeData.RouteCount;
     378  RouteEntry         = Ip6ModeData.RouteCount;
    385379  for (Index = 0; Index < Ip6ModeData.RouteCount; Index++) {
    386380    if (NetIp6IsNetEqual (TargetIp, &Ip6ModeData.RouteTable[Index].Destination, Ip6ModeData.RouteTable[Index].PrefixLength)) {
    387381      if (SubnetPrefixLength < Ip6ModeData.RouteTable[Index].PrefixLength) {
    388382        SubnetPrefixLength = Ip6ModeData.RouteTable[Index].PrefixLength;
    389         RouteEntry = Index;
     383        RouteEntry         = Index;
    390384      }
    391385    }
    392386  }
     387
    393388  if (RouteEntry != Ip6ModeData.RouteCount) {
    394389    IP6_COPY_ADDRESS (&NvData->Gateway, &Ip6ModeData.RouteTable[RouteEntry].Gateway);
    … …  
    399394    FreePool (Ip6ModeData.AddressList);
    400395  }
    401   if (Ip6ModeData.GroupTable!= NULL) {
     396
     397  if (Ip6ModeData.GroupTable != NULL) {
    402398    FreePool (Ip6ModeData.GroupTable);
    403399  }
    404   if (Ip6ModeData.RouteTable!= NULL) {
     400
     401  if (Ip6ModeData.RouteTable != NULL) {
    405402    FreePool (Ip6ModeData.RouteTable);
    406403  }
    407   if (Ip6ModeData.NeighborCache!= NULL) {
     404
     405  if (Ip6ModeData.NeighborCache != NULL) {
    408406    FreePool (Ip6ModeData.NeighborCache);
    409407  }
    410   if (Ip6ModeData.PrefixTable!= NULL) {
     408
     409  if (Ip6ModeData.PrefixTable != NULL) {
    411410    FreePool (Ip6ModeData.PrefixTable);
    412411  }
    413   if (Ip6ModeData.IcmpTypeList!= NULL) {
     412
     413  if (Ip6ModeData.IcmpTypeList != NULL) {
    414414    FreePool (Ip6ModeData.IcmpTypeList);
    415415  }
    416416
    417417  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**/
     429STATIC
     430VOID
     431IScsiSessionResetAuthData (
     432  IN OUT ISCSI_SESSION  *Session
     433  )
     434{
     435  if (Session->AuthType == ISCSI_AUTH_TYPE_CHAP) {
     436    Session->AuthData.CHAP.Hash = NULL;
     437  }
    418438}
    419439
    … …  
    471491    // Login through the newly created connection.
    472492    //
     493    IScsiSessionResetAuthData (Session);
    473494    Status = IScsiConnLogin (Conn, Session->ConfigData->SessionConfigData.ConnectTimeout);
    474495    if (EFI_ERROR (Status)) {
    … …  
    497518                    Conn->TcpIo.Handle,
    498519                    ProtocolGuid,
    499                     (VOID **) &Tcp,
     520                    (VOID **)&Tcp,
    500521                    Session->Private->Image,
    501522                    Session->Private->ExtScsiPassThruHandle,
    … …  
    513534}
    514535
    515 
    516536/**
    517537  Wait for IPsec negotiation, then try to login the iSCSI session again.
    … …  
    529549  )
    530550{
    531 
    532   EFI_STATUS                Status;
    533   EFI_STATUS                TimerStatus;
    534   EFI_EVENT                 Timer;
     551  EFI_STATUS  Status;
     552  EFI_STATUS  TimerStatus;
     553  EFI_EVENT   Timer;
    535554
    536555  Status = gBS->CreateEvent (EVT_TIMER, TPL_CALLBACK, NULL, NULL, &Timer);
    … …  
    551570
    552571  do {
    553 
    554572    TimerStatus = gBS->CheckEvent (Timer);
    555573
    … …  
    557575      Status = IScsiSessionLogin (Session);
    558576    }
    559 
    560577  } while (TimerStatus == EFI_NOT_READY);
    561578
    … …  
    563580  return Status;
    564581}
    565 
    566582
    567583/**
    … …  
    592608    return EFI_DEVICE_ERROR;
    593609  }
     610
    594611  //
    595612  // Send it to the iSCSI target.
    … …  
    601618  return Status;
    602619}
    603 
    604620
    605621/**
    … …  
    629645    return Status;
    630646  }
     647
    631648  ASSERT (Pdu != NULL);
    632649
    … …  
    640657  return Status;
    641658}
    642 
    643659
    644660/**
    … …  
    660676EFI_STATUS
    661677IScsiAddKeyValuePair (
    662   IN OUT NET_BUF      *Pdu,
    663   IN CHAR8            *Key,
    664   IN CHAR8            *Value
    665   )
    666 {
    667   UINT32              DataSegLen;
    668   UINT32              KeyLen;
    669   UINT32              ValueLen;
    670   UINT32              TotalLen;
    671   ISCSI_LOGIN_REQUEST *LoginReq;
    672   CHAR8               *Data;
    673 
    674   LoginReq    = (ISCSI_LOGIN_REQUEST *) NetbufGetByte (Pdu, 0, NULL);
     678  IN OUT NET_BUF  *Pdu,
     679  IN CHAR8        *Key,
     680  IN CHAR8        *Value
     681  )
     682{
     683  UINT32               DataSegLen;
     684  UINT32               KeyLen;
     685  UINT32               ValueLen;
     686  UINT32               TotalLen;
     687  ISCSI_LOGIN_REQUEST  *LoginReq;
     688  CHAR8                *Data;
     689
     690  LoginReq = (ISCSI_LOGIN_REQUEST *)NetbufGetByte (Pdu, 0, NULL);
    675691  if (LoginReq == NULL) {
    676692    return EFI_PROTOCOL_ERROR;
    677693  }
    678   DataSegLen  = NTOH24 (LoginReq->DataSegmentLength);
    679 
    680   KeyLen      = (UINT32) AsciiStrLen (Key);
    681   ValueLen    = (UINT32) AsciiStrLen (Value);
     694
     695  DataSegLen = NTOH24 (LoginReq->DataSegmentLength);
     696
     697  KeyLen   = (UINT32)AsciiStrLen (Key);
     698  ValueLen = (UINT32)AsciiStrLen (Value);
    682699
    683700  //
    … …  
    690707  // Allocate the space for the key-value pair.
    691708  //
    692   Data = (CHAR8 *) NetbufAllocSpace (Pdu, TotalLen, NET_BUF_TAIL);
     709  Data = (CHAR8 *)NetbufAllocSpace (Pdu, TotalLen, NET_BUF_TAIL);
    693710  if (Data == NULL) {
    694711    return EFI_OUT_OF_RESOURCES;
    695712  }
     713
    696714  //
    697715  // Add the key.
    … …  
    718736  return EFI_SUCCESS;
    719737}
    720 
    721738
    722739/**
    … …  
    734751  )
    735752{
    736   ISCSI_SESSION       *Session;
    737   NET_BUF             *Nbuf;
    738   ISCSI_LOGIN_REQUEST *LoginReq;
    739   EFI_STATUS          Status;
     753  ISCSI_SESSION        *Session;
     754  NET_BUF              *Nbuf;
     755  ISCSI_LOGIN_REQUEST  *LoginReq;
     756  EFI_STATUS           Status;
    740757
    741758  Session = Conn->Session;
    742759
    743   Nbuf    = NetbufAlloc (sizeof (ISCSI_LOGIN_REQUEST) + DEFAULT_MAX_RECV_DATA_SEG_LEN);
     760  Nbuf = NetbufAlloc (sizeof (ISCSI_LOGIN_REQUEST) + DEFAULT_MAX_RECV_DATA_SEG_LEN);
    744761  if (Nbuf == NULL) {
    745762    return NULL;
    746763  }
    747764
    748   LoginReq = (ISCSI_LOGIN_REQUEST *) NetbufAllocSpace (Nbuf, sizeof (ISCSI_LOGIN_REQUEST), NET_BUF_TAIL);
     765  LoginReq = (ISCSI_LOGIN_REQUEST *)NetbufAllocSpace (Nbuf, sizeof (ISCSI_LOGIN_REQUEST), NET_BUF_TAIL);
    749766  if (LoginReq == NULL) {
    750767    NetbufFree (Nbuf);
    751768    return NULL;
    752769  }
     770
    753771  ZeroMem (LoginReq, sizeof (ISCSI_LOGIN_REQUEST));
    754772
    … …  
    758776  ISCSI_SET_OPCODE (LoginReq, ISCSI_OPCODE_LOGIN_REQ, ISCSI_REQ_IMMEDIATE);
    759777  ISCSI_SET_STAGES (LoginReq, Conn->CurrentStage, Conn->NextStage);
    760   LoginReq->VersionMax        = ISCSI_VERSION_MAX;
    761   LoginReq->VersionMin        = ISCSI_VERSION_MIN;
    762   LoginReq->Tsih              = HTONS (Session->Tsih);
    763   LoginReq->InitiatorTaskTag  = HTONL (Session->InitiatorTaskTag);
    764   LoginReq->Cid               = HTONS (Conn->Cid);
    765   LoginReq->CmdSN             = HTONL (Session->CmdSN);
     778  LoginReq->VersionMax       = ISCSI_VERSION_MAX;
     779  LoginReq->VersionMin       = ISCSI_VERSION_MIN;
     780  LoginReq->Tsih             = HTONS (Session->Tsih);
     781  LoginReq->InitiatorTaskTag = HTONL (Session->InitiatorTaskTag);
     782  LoginReq->Cid              = HTONS (Conn->Cid);
     783  LoginReq->CmdSN            = HTONL (Session->CmdSN);
    766784
    767785  //
    … …  
    785803
    786804  switch (Conn->CurrentStage) {
    787   case ISCSI_SECURITY_NEGOTIATION:
    788     //
    789     // Both none authentication and CHAP authentication share the CHAP path.
    790     //
    791     //
    792     if (Session->AuthType != ISCSI_AUTH_TYPE_KRB) {
    793       Status = IScsiCHAPToSendReq (Conn, Nbuf);
    794     }
    795 
    796     break;
    797 
    798   case ISCSI_LOGIN_OPERATIONAL_NEGOTIATION:
    799     //
    800     // Only negotiate the parameter once.
    801     //
    802     if (!Conn->ParamNegotiated) {
    803       IScsiFillOpParams (Conn, Nbuf);
    804     }
    805 
    806     ISCSI_SET_FLAG (LoginReq, ISCSI_LOGIN_REQ_PDU_FLAG_TRANSIT);
    807     break;
    808 
    809   default:
    810     //
    811     // An error occurs...
    812     //
    813     Status = EFI_DEVICE_ERROR;
    814     break;
     805    case ISCSI_SECURITY_NEGOTIATION:
     806      //
     807      // Both none authentication and CHAP authentication share the CHAP path.
     808      //
     809      //
     810      if (Session->AuthType != ISCSI_AUTH_TYPE_KRB) {
     811        Status = IScsiCHAPToSendReq (Conn, Nbuf);
     812      }
     813
     814      break;
     815
     816    case ISCSI_LOGIN_OPERATIONAL_NEGOTIATION:
     817      //
     818      // Only negotiate the parameter once.
     819      //
     820      if (!Conn->ParamNegotiated) {
     821        IScsiFillOpParams (Conn, Nbuf);
     822      }
     823
     824      ISCSI_SET_FLAG (LoginReq, ISCSI_LOGIN_REQ_PDU_FLAG_TRANSIT);
     825      break;
     826
     827    default:
     828      //
     829      // An error occurs...
     830      //
     831      Status = EFI_DEVICE_ERROR;
     832      break;
    815833  }
    816834
    … …  
    831849  return Nbuf;
    832850}
    833 
    834851
    835852/**
    … …  
    861878  UINT32                DataSegLen;
    862879
    863   Status   = EFI_SUCCESS;
    864   Session   = Conn->Session;
    865 
    866   LoginRsp  = (ISCSI_LOGIN_RESPONSE *) NetbufGetByte (Pdu, 0, NULL);
     880  Status  = EFI_SUCCESS;
     881  Session = Conn->Session;
     882
     883  LoginRsp = (ISCSI_LOGIN_RESPONSE *)NetbufGetByte (Pdu, 0, NULL);
    867884  if (LoginRsp == NULL) {
    868885    return EFI_PROTOCOL_ERROR;
    869886  }
     887
    870888  if (!ISCSI_CHECK_OPCODE (LoginRsp, ISCSI_OPCODE_LOGIN_RSP)) {
    871889    //
    … …  
    874892    return EFI_PROTOCOL_ERROR;
    875893  }
     894
    876895  //
    877896  // Get the data segment, if any.
    … …  
    883902    DataSeg = NULL;
    884903  }
     904
    885905  //
    886906  // Check the status class in the login response PDU.
    887907  //
    888908  switch (LoginRsp->StatusClass) {
    889   case ISCSI_LOGIN_STATUS_SUCCESS:
    890     //
    891     // Just break here; the response and the data segment will be processed later.
    892     //
    893     break;
    894 
    895   case ISCSI_LOGIN_STATUS_REDIRECTION:
    896     //
    897     // The target may be moved to a different address.
    898     //
    899     if (DataSeg == NULL) {
     909    case ISCSI_LOGIN_STATUS_SUCCESS:
     910      //
     911      // Just break here; the response and the data segment will be processed later.
     912      //
     913      break;
     914
     915    case ISCSI_LOGIN_STATUS_REDIRECTION:
     916      //
     917      // The target may be moved to a different address.
     918      //
     919      if (DataSeg == NULL) {
     920        return EFI_PROTOCOL_ERROR;
     921      }
     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      //
     933      // Session will be restarted on this error status because the Target is
     934      // redirected by this Login Response.
     935      //
     936      return EFI_MEDIA_CHANGED;
     937
     938    default:
     939      //
     940      // Initiator Error, Target Error, or any other undefined error code.
     941      //
    900942      return EFI_PROTOCOL_ERROR;
    901     }
    902     //
    903     // Process the TargetAddress key-value strings in the data segment to update the
    904     // target address info.
    905     //
    906     Status = IScsiUpdateTargetAddress (Session, (CHAR8 *) DataSeg, DataSegLen);
    907     if (EFI_ERROR (Status)) {
    908       return Status;
    909     }
    910     //
    911     // Session will be restarted on this error status because the Target is
    912     // redirected by this Login Response.
    913     //
    914     return EFI_MEDIA_CHANGED;
    915 
    916   default:
    917     //
    918     // Initiator Error, Target Error, or any other undefined error code.
    919     //
    920     return EFI_PROTOCOL_ERROR;
    921   }
     943  }
     944
    922945  //
    923946  // The status is success; extract the wanted fields from the header segment.
    924947  //
    925   Transit                     = ISCSI_FLAG_ON (LoginRsp, ISCSI_LOGIN_RSP_PDU_FLAG_TRANSIT);
    926   Continue                    = ISCSI_FLAG_ON (LoginRsp, ISCSI_LOGIN_RSP_PDU_FLAG_CONTINUE);
    927 
    928   CurrentStage                = ISCSI_GET_CURRENT_STAGE (LoginRsp);
    929   NextStage                   = ISCSI_GET_NEXT_STAGE (LoginRsp);
    930 
    931   LoginRsp->InitiatorTaskTag  = NTOHL (LoginRsp->InitiatorTaskTag);
     948  Transit  = ISCSI_FLAG_ON (LoginRsp, ISCSI_LOGIN_RSP_PDU_FLAG_TRANSIT);
     949  Continue = ISCSI_FLAG_ON (LoginRsp, ISCSI_LOGIN_RSP_PDU_FLAG_CONTINUE);
     950
     951  CurrentStage = ISCSI_GET_CURRENT_STAGE (LoginRsp);
     952  NextStage    = ISCSI_GET_NEXT_STAGE (LoginRsp);
     953
     954  LoginRsp->InitiatorTaskTag = NTOHL (LoginRsp->InitiatorTaskTag);
    932955
    933956  if ((Transit && Continue) ||
    … …  
    937960      (CompareMem (Session->Isid, LoginRsp->Isid, sizeof (LoginRsp->Isid)) != 0) ||
    938961      (LoginRsp->InitiatorTaskTag != Session->InitiatorTaskTag)
    939       ) {
     962      )
     963  {
    940964    //
    941965    // A Login Response with the C bit set to 1 MUST have the T bit set to 0.
    … …  
    949973  }
    950974
    951   LoginRsp->StatSN    = NTOHL (LoginRsp->StatSN);
    952   LoginRsp->ExpCmdSN  = NTOHL (LoginRsp->ExpCmdSN);
    953   LoginRsp->MaxCmdSN  = NTOHL (LoginRsp->MaxCmdSN);
     975  LoginRsp->StatSN   = NTOHL (LoginRsp->StatSN);
     976  LoginRsp->ExpCmdSN = NTOHL (LoginRsp->ExpCmdSN);
     977  LoginRsp->MaxCmdSN = NTOHL (LoginRsp->MaxCmdSN);
    954978
    955979  if ((Conn->CurrentStage == ISCSI_SECURITY_NEGOTIATION) && (Conn->AuthStep == ISCSI_AUTH_INITIAL)) {
    … …  
    9831007    }
    9841008  }
     1009
    9851010  //
    9861011  // Trim off the header segment.
    … …  
    10061031
    10071032  switch (CurrentStage) {
    1008   case ISCSI_SECURITY_NEGOTIATION:
    1009     //
    1010     // In security negotiation stage, let CHAP module handle it.
    1011     //
    1012     if (Session->AuthType != ISCSI_AUTH_TYPE_KRB) {
    1013       Status = IScsiCHAPOnRspReceived (Conn);
    1014     }
    1015     break;
    1016 
    1017   case ISCSI_LOGIN_OPERATIONAL_NEGOTIATION:
    1018     //
    1019     // Response received with negotiation response on iSCSI parameters: check them.
    1020     //
    1021     Status = IScsiCheckOpParams (Conn);
    1022     if (!EFI_ERROR (Status)) {
    1023       Conn->ParamNegotiated = TRUE;
    1024     }
    1025 
    1026     break;
    1027 
    1028   default:
    1029     //
    1030     // Should never get here.
    1031     //
    1032     Status = EFI_PROTOCOL_ERROR;
    1033     break;
     1033    case ISCSI_SECURITY_NEGOTIATION:
     1034      //
     1035      // In security negotiation stage, let CHAP module handle it.
     1036      //
     1037      if (Session->AuthType != ISCSI_AUTH_TYPE_KRB) {
     1038        Status = IScsiCHAPOnRspReceived (Conn);
     1039      }
     1040
     1041      break;
     1042
     1043    case ISCSI_LOGIN_OPERATIONAL_NEGOTIATION:
     1044      //
     1045      // Response received with negotiation response on iSCSI parameters: check them.
     1046      //
     1047      Status = IScsiCheckOpParams (Conn);
     1048      if (!EFI_ERROR (Status)) {
     1049        Conn->ParamNegotiated = TRUE;
     1050      }
     1051
     1052      break;
     1053
     1054    default:
     1055      //
     1056      // Should never get here.
     1057      //
     1058      Status = EFI_PROTOCOL_ERROR;
     1059      break;
    10341060  }
    10351061
    … …  
    10501076    }
    10511077  }
     1078
    10521079  //
    10531080  // Flush the response(s) received.
    … …  
    10571084  return Status;
    10581085}
    1059 
    10601086
    10611087/**
    … …  
    10761102EFI_STATUS
    10771103IScsiUpdateTargetAddress (
    1078   IN OUT ISCSI_SESSION         *Session,
    1079   IN     CHAR8                 *Data,
    1080   IN     UINT32                Len
     1104  IN OUT ISCSI_SESSION  *Session,
     1105  IN     CHAR8          *Data,
     1106  IN     UINT32         Len
    10811107  )
    10821108{
    … …  
    11201146        TargetAddress++;
    11211147      }
    1122     } else if (*TargetAddress == ISCSI_REDIRECT_ADDR_START_DELIMITER){
     1148    } else if (*TargetAddress == ISCSI_REDIRECT_ADDR_START_DELIMITER) {
    11231149      //
    11241150      // The domainname of the target is presented in a bracketed IPv6 address format.
    11251151      //
    1126       TargetAddress ++;
     1152      TargetAddress++;
    11271153      IpStr = TargetAddress;
    11281154      while ((*TargetAddress != '\0') && (*TargetAddress != ISCSI_REDIRECT_ADDR_END_DELIMITER)) {
    … …  
    11381164
    11391165      *TargetAddress = '\0';
    1140       TargetAddress ++;
    1141 
     1166      TargetAddress++;
    11421167    } else {
    11431168      //
    … …  
    11491174        TargetAddress++;
    11501175      }
     1176
    11511177      NvData->DnsMode = TRUE;
    11521178    }
    … …  
    11721198        continue;
    11731199      } else {
    1174         NvData->TargetPort = (UINT16) Number;
     1200        NvData->TargetPort = (UINT16)Number;
    11751201      }
    11761202    } else {
    … …  
    12001226      // do DNS resolution when creating a TCP connection.
    12011227      //
    1202       if (AsciiStrSize (IpStr) > sizeof (Session->ConfigData->SessionConfigData.TargetUrl)){
     1228      if (AsciiStrSize (IpStr) > sizeof (Session->ConfigData->SessionConfigData.TargetUrl)) {
    12031229        return EFI_INVALID_PARAMETER;
    12041230      }
     1231
    12051232      CopyMem (&Session->ConfigData->SessionConfigData.TargetUrl, IpStr, AsciiStrSize (IpStr));
    12061233    } else {
    … …  
    12251252}
    12261253
    1227 
    12281254/**
    12291255  The callback function to free the net buffer list.
    … …  
    12351261EFIAPI
    12361262IScsiFreeNbufList (
    1237   VOID *Arg
     1263  VOID  *Arg
    12381264  )
    12391265{
    12401266  ASSERT (Arg != NULL);
    12411267
    1242   NetbufFreeList ((LIST_ENTRY *) Arg);
     1268  NetbufFreeList ((LIST_ENTRY *)Arg);
    12431269  FreePool (Arg);
    12441270}
    1245 
    12461271
    12471272/**
    … …  
    12541279EFIAPI
    12551280IScsiNbufExtFree (
    1256   VOID *Arg
    1257   )
    1258 {
    1259 }
    1260 
     1281  VOID  *Arg
     1282  )
     1283{
     1284}
    12611285
    12621286/**
    … …  
    12821306EFI_STATUS
    12831307IScsiReceivePdu (
    1284   IN ISCSI_CONNECTION                      *Conn,
    1285   OUT NET_BUF                              **Pdu,
    1286   IN ISCSI_IN_BUFFER_CONTEXT               *Context, OPTIONAL
    1287   IN BOOLEAN                               HeaderDigest,
    1288   IN BOOLEAN                               DataDigest,
    1289   IN EFI_EVENT                             TimeoutEvent OPTIONAL
    1290   )
    1291 {
    1292   LIST_ENTRY      *NbufList;
    1293   UINT32          Len;
    1294   NET_BUF         *PduHdr;
    1295   UINT8           *Header;
    1296   EFI_STATUS      Status;
    1297   UINT32          PadLen;
    1298   UINT32          InDataOffset;
    1299   NET_FRAGMENT    Fragment[2];
    1300   UINT32          FragmentCount;
    1301   NET_BUF         *DataSeg;
    1302   UINT32          PadAndCRC32[2];
     1308  IN ISCSI_CONNECTION         *Conn,
     1309  OUT NET_BUF                 **Pdu,
     1310  IN ISCSI_IN_BUFFER_CONTEXT  *Context  OPTIONAL,
     1311  IN BOOLEAN                  HeaderDigest,
     1312  IN BOOLEAN                  DataDigest,
     1313  IN EFI_EVENT                TimeoutEvent OPTIONAL
     1314  )
     1315{
     1316  LIST_ENTRY    *NbufList;
     1317  UINT32        Len;
     1318  NET_BUF       *PduHdr;
     1319  UINT8         *Header;
     1320  EFI_STATUS    Status;
     1321  UINT32        PadLen;
     1322  UINT32        InDataOffset;
     1323  NET_FRAGMENT  Fragment[2];
     1324  UINT32        FragmentCount;
     1325  NET_BUF       *DataSeg;
     1326  UINT32        PadAndCRC32[2];
    13031327
    13041328  NbufList = AllocatePool (sizeof (LIST_ENTRY));
    … …  
    13121336  // The header digest will be received together with the PDU header, if exists.
    13131337  //
    1314   Len     = sizeof (ISCSI_BASIC_HEADER) + (HeaderDigest ? sizeof (UINT32) : 0);
    1315   PduHdr  = NetbufAlloc (Len);
     1338  Len    = sizeof (ISCSI_BASIC_HEADER) + (HeaderDigest ? sizeof (UINT32) : 0);
     1339  PduHdr = NetbufAlloc (Len);
    13161340  if (PduHdr == NULL) {
    13171341    Status = EFI_OUT_OF_RESOURCES;
    … …  
    13241348    goto ON_EXIT;
    13251349  }
     1350
    13261351  InsertTailList (NbufList, &PduHdr->List);
    13271352
    … …  
    13521377    goto FORM_PDU;
    13531378  }
     1379
    13541380  //
    13551381  // Get the length of the padding bytes of the data segment.
    … …  
    13581384
    13591385  switch (ISCSI_GET_OPCODE (Header)) {
    1360   case ISCSI_OPCODE_SCSI_DATA_IN:
    1361     //
    1362     // To reduce memory copy overhead, try to use the buffer described by Context
    1363     // if the PDU is an iSCSI SCSI data.
    1364     //
    1365     InDataOffset = ISCSI_GET_BUFFER_OFFSET (Header);
    1366     if ((Context == NULL) || ((InDataOffset + Len) > Context->InDataLen)) {
     1386    case ISCSI_OPCODE_SCSI_DATA_IN:
     1387      //
     1388      // To reduce memory copy overhead, try to use the buffer described by Context
     1389      // if the PDU is an iSCSI SCSI data.
     1390      //
     1391      InDataOffset = ISCSI_GET_BUFFER_OFFSET (Header);
     1392      if ((Context == NULL) || ((InDataOffset + Len) > Context->InDataLen)) {
     1393        Status = EFI_PROTOCOL_ERROR;
     1394        goto ON_EXIT;
     1395      }
     1396
     1397      Fragment[0].Len  = Len;
     1398      Fragment[0].Bulk = Context->InData + InDataOffset;
     1399
     1400      if (DataDigest || (PadLen != 0)) {
     1401        //
     1402        // The data segment is padded. Use two fragments to receive it:
     1403        // the first to receive the useful data; the second to receive the padding.
     1404        //
     1405        Fragment[1].Len  = PadLen + (DataDigest ? sizeof (UINT32) : 0);
     1406        Fragment[1].Bulk = (UINT8 *)PadAndCRC32 + (4 - PadLen);
     1407
     1408        FragmentCount = 2;
     1409      } else {
     1410        FragmentCount = 1;
     1411      }
     1412
     1413      DataSeg = NetbufFromExt (&Fragment[0], FragmentCount, 0, 0, IScsiNbufExtFree, NULL);
     1414      if (DataSeg == NULL) {
     1415        Status = EFI_OUT_OF_RESOURCES;
     1416        goto ON_EXIT;
     1417      }
     1418
     1419      break;
     1420
     1421    case ISCSI_OPCODE_SCSI_RSP:
     1422    case ISCSI_OPCODE_NOP_IN:
     1423    case ISCSI_OPCODE_LOGIN_RSP:
     1424    case ISCSI_OPCODE_TEXT_RSP:
     1425    case ISCSI_OPCODE_ASYNC_MSG:
     1426    case ISCSI_OPCODE_REJECT:
     1427    case ISCSI_OPCODE_VENDOR_T0:
     1428    case ISCSI_OPCODE_VENDOR_T1:
     1429    case ISCSI_OPCODE_VENDOR_T2:
     1430      //
     1431      // Allocate buffer to receive the data segment.
     1432      //
     1433      Len    += PadLen + (DataDigest ? sizeof (UINT32) : 0);
     1434      DataSeg = NetbufAlloc (Len);
     1435      if (DataSeg == NULL) {
     1436        Status = EFI_OUT_OF_RESOURCES;
     1437        goto ON_EXIT;
     1438      }
     1439
     1440      NetbufAllocSpace (DataSeg, Len, NET_BUF_TAIL);
     1441      break;
     1442
     1443    default:
    13671444      Status = EFI_PROTOCOL_ERROR;
    13681445      goto ON_EXIT;
    1369     }
    1370 
    1371     Fragment[0].Len   = Len;
    1372     Fragment[0].Bulk  = Context->InData + InDataOffset;
    1373 
    1374     if (DataDigest || (PadLen != 0)) {
    1375       //
    1376       // The data segment is padded. Use two fragments to receive it:
    1377       // the first to receive the useful data; the second to receive the padding.
    1378       //
    1379       Fragment[1].Len   = PadLen + (DataDigest ? sizeof (UINT32) : 0);
    1380       Fragment[1].Bulk  = (UINT8 *)PadAndCRC32 + (4 - PadLen);
    1381 
    1382       FragmentCount     = 2;
    1383     } else {
    1384       FragmentCount = 1;
    1385     }
    1386 
    1387     DataSeg = NetbufFromExt (&Fragment[0], FragmentCount, 0, 0, IScsiNbufExtFree, NULL);
    1388     if (DataSeg == NULL) {
    1389       Status = EFI_OUT_OF_RESOURCES;
    1390       goto ON_EXIT;
    1391     }
    1392 
    1393     break;
    1394 
    1395   case ISCSI_OPCODE_SCSI_RSP:
    1396   case ISCSI_OPCODE_NOP_IN:
    1397   case ISCSI_OPCODE_LOGIN_RSP:
    1398   case ISCSI_OPCODE_TEXT_RSP:
    1399   case ISCSI_OPCODE_ASYNC_MSG:
    1400   case ISCSI_OPCODE_REJECT:
    1401   case ISCSI_OPCODE_VENDOR_T0:
    1402   case ISCSI_OPCODE_VENDOR_T1:
    1403   case ISCSI_OPCODE_VENDOR_T2:
    1404     //
    1405     // Allocate buffer to receive the data segment.
    1406     //
    1407     Len += PadLen + (DataDigest ? sizeof (UINT32) : 0);
    1408     DataSeg = NetbufAlloc (Len);
    1409     if (DataSeg == NULL) {
    1410       Status = EFI_OUT_OF_RESOURCES;
    1411       goto ON_EXIT;
    1412     }
    1413 
    1414     NetbufAllocSpace (DataSeg, Len, NET_BUF_TAIL);
    1415     break;
    1416 
    1417   default:
    1418     Status = EFI_PROTOCOL_ERROR;
    1419     goto ON_EXIT;
    14201446  }
    14211447
    … …  
    14661492}
    14671493
    1468 
    14691494/**
    14701495  Check and get the result of the parameter negotiation.
    … …  
    14821507  )
    14831508{
    1484   EFI_STATUS      Status;
    1485   LIST_ENTRY      *KeyValueList;
    1486   CHAR8           *Data;
    1487   UINT32          Len;
    1488   ISCSI_SESSION   *Session;
    1489   CHAR8           *Value;
    1490   UINTN           NumericValue;
     1509  EFI_STATUS     Status;
     1510  LIST_ENTRY     *KeyValueList;
     1511  CHAR8          *Data;
     1512  UINT32         Len;
     1513  ISCSI_SESSION  *Session;
     1514  CHAR8          *Value;
     1515  UINTN          NumericValue;
    14911516
    14921517  ASSERT (Conn->RspQue.BufNum != 0);
    … …  
    14941519  Session = Conn->Session;
    14951520
    1496   Len     = Conn->RspQue.BufSize;
    1497   Data    = AllocatePool (Len);
     1521  Len  = Conn->RspQue.BufSize;
     1522  Data = AllocatePool (Len);
    14981523  if (Data == NULL) {
    14991524    return EFI_OUT_OF_RESOURCES;
    15001525  }
    15011526
    1502   NetbufQueCopy (&Conn->RspQue, 0, Len, (UINT8 *) Data);
     1527  NetbufQueCopy (&Conn->RspQue, 0, Len, (UINT8 *)Data);
    15031528
    15041529  Status = EFI_PROTOCOL_ERROR;
    … …  
    15121537    return Status;
    15131538  }
     1539
    15141540  //
    15151541  // HeaderDigest
    … …  
    15291555    goto ON_ERROR;
    15301556  }
     1557
    15311558  //
    15321559  // DataDigest
    … …  
    15461573    goto ON_ERROR;
    15471574  }
     1575
    15481576  //
    15491577  // ErrorRecoveryLevel: result function is Minimum.
    … …  
    15591587  }
    15601588
    1561   Session->ErrorRecoveryLevel = (UINT8) MIN (Session->ErrorRecoveryLevel, NumericValue);
     1589  Session->ErrorRecoveryLevel = (UINT8)MIN (Session->ErrorRecoveryLevel, NumericValue);
    15621590
    15631591  //
    … …  
    15701598    }
    15711599
    1572     Session->InitialR2T = (BOOLEAN) (AsciiStrCmp (Value, "Yes") == 0);
     1600    Session->InitialR2T = (BOOLEAN)(AsciiStrCmp (Value, "Yes") == 0);
    15731601  }
    15741602
    … …  
    15811609  }
    15821610
    1583   Session->ImmediateData = (BOOLEAN) (Session->ImmediateData && (BOOLEAN) (AsciiStrCmp (Value, "Yes") == 0));
     1611  Session->ImmediateData = (BOOLEAN)(Session->ImmediateData && (BOOLEAN)(AsciiStrCmp (Value, "Yes") == 0));
    15841612
    15851613  //
    … …  
    15881616  Value = IScsiGetValueByKeyFromList (KeyValueList, ISCSI_KEY_MAX_RECV_DATA_SEGMENT_LENGTH);
    15891617  if (Value != NULL) {
    1590     Conn->MaxRecvDataSegmentLength = (UINT32) IScsiNetNtoi (Value);
    1591   }
     1618    Conn->MaxRecvDataSegmentLength = (UINT32)IScsiNetNtoi (Value);
     1619  }
     1620
    15921621  //
    15931622  // MaxBurstLength: result function is Minimum.
    … …  
    15991628
    16001629  NumericValue            = IScsiNetNtoi (Value);
    1601   Session->MaxBurstLength = (UINT32) MIN (Session->MaxBurstLength, NumericValue);
     1630  Session->MaxBurstLength = (UINT32)MIN (Session->MaxBurstLength, NumericValue);
    16021631
    16031632  //
    … …  
    16121641
    16131642    NumericValue              = IScsiNetNtoi (Value);
    1614     Session->FirstBurstLength = (UINT32) MIN (Session->FirstBurstLength, NumericValue);
     1643    Session->FirstBurstLength = (UINT32)MIN (Session->FirstBurstLength, NumericValue);
    16151644  }
    16161645
    … …  
    16281657  }
    16291658
    1630   Session->MaxConnections = (UINT32) MIN (Session->MaxConnections, NumericValue);
     1659  Session->MaxConnections = (UINT32)MIN (Session->MaxConnections, NumericValue);
    16311660
    16321661  //
    … …  
    16391668    }
    16401669
    1641     Session->DataPDUInOrder = (BOOLEAN) (AsciiStrCmp (Value, "Yes") == 0);
     1670    Session->DataPDUInOrder = (BOOLEAN)(AsciiStrCmp (Value, "Yes") == 0);
    16421671  }
    16431672
    … …  
    16511680    }
    16521681
    1653     Session->DataSequenceInOrder = (BOOLEAN) (AsciiStrCmp (Value, "Yes") == 0);
     1682    Session->DataSequenceInOrder = (BOOLEAN)(AsciiStrCmp (Value, "Yes") == 0);
    16541683  }
    16551684
    … …  
    16681697    goto ON_ERROR;
    16691698  } else {
    1670     Session->DefaultTime2Wait = (UINT32) MAX (Session->DefaultTime2Wait, NumericValue);
    1671   }
     1699    Session->DefaultTime2Wait = (UINT32)MAX (Session->DefaultTime2Wait, NumericValue);
     1700  }
     1701
    16721702  //
    16731703  // DefaultTime2Retain: result function is Minimum.
    … …  
    16841714    goto ON_ERROR;
    16851715  } else {
    1686     Session->DefaultTime2Retain = (UINT32) MIN (Session->DefaultTime2Retain, NumericValue);
    1687   }
     1716    Session->DefaultTime2Retain = (UINT32)MIN (Session->DefaultTime2Retain, NumericValue);
     1717  }
     1718
    16881719  //
    16891720  // MaxOutstandingR2T: result function is Minimum.
    … …  
    16991730  }
    17001731
    1701   Session->MaxOutstandingR2T = (UINT16) MIN (Session->MaxOutstandingR2T, NumericValue);
     1732  Session->MaxOutstandingR2T = (UINT16)MIN (Session->MaxOutstandingR2T, NumericValue);
    17021733
    17031734  //
    … …  
    17081739  IScsiGetValueByKeyFromList (KeyValueList, ISCSI_KEY_TARGET_PORTAL_GROUP_TAG);
    17091740
    1710 
    17111741  //
    17121742  // Remove the key-value that may not needed for result function is OR.
    … …  
    17381768  return Status;
    17391769}
    1740 
    17411770
    17421771/**
    … …  
    17531782  )
    17541783{
    1755   ISCSI_SESSION *Session;
    1756   CHAR8         Value[256];
     1784  ISCSI_SESSION  *Session;
     1785  CHAR8          Value[256];
    17571786
    17581787  Session = Conn->Session;
    … …  
    18001829  IScsiAddKeyValuePair (Pdu, ISCSI_KEY_MAX_OUTSTANDING_R2T, Value);
    18011830}
    1802 
    18031831
    18041832/**
    … …  
    18141842EFI_STATUS
    18151843IScsiPadSegment (
    1816   IN OUT NET_BUF      *Pdu,
    1817   IN     UINT32       Len
     1844  IN OUT NET_BUF  *Pdu,
     1845  IN     UINT32   Len
    18181846  )
    18191847{
    … …  
    18351863}
    18361864
    1837 
    18381865/**
    18391866  Build a key-value list from the data segment.
    … …  
    18481875LIST_ENTRY *
    18491876IScsiBuildKeyValueList (
    1850   IN CHAR8  *Data,
    1851   IN UINT32 Len
     1877  IN CHAR8   *Data,
     1878  IN UINT32  Len
    18521879  )
    18531880{
    … …  
    18891916    KeyValuePair->Value = Data;
    18901917
    1891     InsertTailList (ListHead, &KeyValuePair->List);;
     1918    InsertTailList (ListHead, &KeyValuePair->List);
    18921919
    18931920    Data += AsciiStrLen (KeyValuePair->Value) + 1;
    1894     Len -= (UINT32) AsciiStrLen (KeyValuePair->Value) + 1;
     1921    Len  -= (UINT32)AsciiStrLen (KeyValuePair->Value) + 1;
    18951922  }
    18961923
    … …  
    19031930  return NULL;
    19041931}
    1905 
    19061932
    19071933/**
    … …  
    19181944CHAR8 *
    19191945IScsiGetValueByKeyFromList (
    1920   IN OUT LIST_ENTRY     *KeyValueList,
    1921   IN     CHAR8          *Key
     1946  IN OUT LIST_ENTRY  *KeyValueList,
     1947  IN     CHAR8       *Key
    19221948  )
    19231949{
    … …  
    19431969}
    19441970
    1945 
    19461971/**
    19471972  Free the key-value list.
    … …  
    19521977VOID
    19531978IScsiFreeKeyValueList (
    1954   IN LIST_ENTRY      *KeyValueList
     1979  IN LIST_ENTRY  *KeyValueList
    19551980  )
    19561981{
    … …  
    19591984
    19601985  while (!IsListEmpty (KeyValueList)) {
    1961     Entry         = NetListRemoveHead (KeyValueList);
    1962     KeyValuePair  = NET_LIST_USER_STRUCT (Entry, ISCSI_KEY_VALUE_PAIR, List);
     1986    Entry        = NetListRemoveHead (KeyValueList);
     1987    KeyValuePair = NET_LIST_USER_STRUCT (Entry, ISCSI_KEY_VALUE_PAIR, List);
    19631988
    19641989    FreePool (KeyValuePair);
    … …  
    19671992  FreePool (KeyValueList);
    19681993}
    1969 
    19701994
    19711995/**
    … …  
    19812005EFI_STATUS
    19822006IScsiNormalizeName (
    1983   IN OUT CHAR8      *Name,
    1984   IN     UINTN      Len
    1985   )
    1986 {
    1987   UINTN Index;
     2007  IN OUT CHAR8  *Name,
     2008  IN     UINTN  Len
     2009  )
     2010{
     2011  UINTN  Index;
    19882012
    19892013  for (Index = 0; Index < Len; Index++) {
    … …  
    19922016      // Convert the upper-case characters to lower-case ones.
    19932017      //
    1994       Name[Index] = (CHAR8) (Name[Index] - 'A' + 'a');
     2018      Name[Index] = (CHAR8)(Name[Index] - 'A' + 'a');
    19952019    }
    19962020
    … …  
    20002024        (Name[Index] != '.') &&
    20012025        (Name[Index] != ':')
    2002         ) {
     2026        )
     2027    {
    20032028      //
    20042029      // ASCII dash, dot, colon lower-case characters and digit characters
    … …  
    20182043  return EFI_SUCCESS;
    20192044}
    2020 
    20212045
    20222046/**
    … …  
    20372061  )
    20382062{
    2039   ISCSI_SESSION *Session;
    2040   ISCSI_TCB     *NewTcb;
     2063  ISCSI_SESSION  *Session;
     2064  ISCSI_TCB      *NewTcb;
    20412065
    20422066  ASSERT (Tcb != NULL);
    … …  
    20552079  InitializeListHead (&NewTcb->Link);
    20562080
    2057   NewTcb->SoFarInOrder      = TRUE;
    2058   NewTcb->InitiatorTaskTag  = Session->InitiatorTaskTag;
    2059   NewTcb->CmdSN             = Session->CmdSN;
    2060   NewTcb->Conn              = Conn;
     2081  NewTcb->SoFarInOrder     = TRUE;
     2082  NewTcb->InitiatorTaskTag = Session->InitiatorTaskTag;
     2083  NewTcb->CmdSN            = Session->CmdSN;
     2084  NewTcb->Conn             = Conn;
    20612085
    20622086  InsertTailList (&Session->TcbList, &NewTcb->Link);
    … …  
    20722096  return EFI_SUCCESS;
    20732097}
    2074 
    20752098
    20762099/**
    … …  
    20892112  FreePool (Tcb);
    20902113}
    2091 
    20922114
    20932115/**
    … …  
    21132135  NET_BUF       *DataSeg;
    21142136
    2115   Fragment[0].Len   = Len;
    2116   Fragment[0].Bulk  = Data;
    2117 
    2118   PadLen            = ISCSI_GET_PAD_LEN (Len);
     2137  Fragment[0].Len  = Len;
     2138  Fragment[0].Bulk = Data;
     2139
     2140  PadLen = ISCSI_GET_PAD_LEN (Len);
    21192141  if (PadLen != 0) {
    2120     Fragment[1].Len   = PadLen;
    2121     Fragment[1].Bulk  = (UINT8 *) &mDataSegPad;
    2122 
    2123     FragmentCount     = 2;
     2142    Fragment[1].Len  = PadLen;
     2143    Fragment[1].Bulk = (UINT8 *)&mDataSegPad;
     2144
     2145    FragmentCount = 2;
    21242146  } else {
    21252147    FragmentCount = 1;
    … …  
    21302152  return DataSeg;
    21312153}
    2132 
    21332154
    21342155/**
    … …  
    21462167NET_BUF *
    21472168IScsiNewScsiCmdPdu (
    2148   IN EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET *Packet,
    2149   IN UINT64                                     Lun,
    2150   IN ISCSI_TCB                                  *Tcb
     2169  IN EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET  *Packet,
     2170  IN UINT64                                      Lun,
     2171  IN ISCSI_TCB                                   *Tcb
    21512172  )
    21522173{
    … …  
    21772198    // The CDB exceeds 16 bytes. An extended CDB AHS is required.
    21782199    //
    2179     AHSLength = (UINT8) (AHSLength + ISCSI_ROUNDUP (Packet->CdbLength - 16) + sizeof (ISCSI_ADDITIONAL_HEADER));
     2200    AHSLength = (UINT8)(AHSLength + ISCSI_ROUNDUP (Packet->CdbLength - 16) + sizeof (ISCSI_ADDITIONAL_HEADER));
    21802201  }
    21812202
    … …  
    21862207  }
    21872208
    2188   ScsiCmd = (SCSI_COMMAND *) NetbufAllocSpace (PduHeader, Length, NET_BUF_TAIL);
     2209  ScsiCmd = (SCSI_COMMAND *)NetbufAllocSpace (PduHeader, Length, NET_BUF_TAIL);
    21892210  if (ScsiCmd == NULL) {
    21902211    NetbufFree (PduHeader);
    21912212    return NULL;
    21922213  }
    2193   Header  = (ISCSI_ADDITIONAL_HEADER *) (ScsiCmd + 1);
     2214
     2215  Header = (ISCSI_ADDITIONAL_HEADER *)(ScsiCmd + 1);
    21942216
    21952217  ZeroMem (ScsiCmd, Length);
    … …  
    22022224  //
    22032225  switch (Packet->DataDirection) {
    2204   case DataIn:
    2205     ISCSI_SET_FLAG (ScsiCmd, SCSI_CMD_PDU_FLAG_READ);
    2206     ScsiCmd->ExpDataXferLength = NTOHL (Packet->InTransferLength);
    2207     break;
    2208 
    2209   case DataOut:
    2210     ISCSI_SET_FLAG (ScsiCmd, SCSI_CMD_PDU_FLAG_WRITE);
    2211     ScsiCmd->ExpDataXferLength = NTOHL (Packet->OutTransferLength);
    2212     break;
    2213 
    2214   case DataBi:
    2215     ISCSI_SET_FLAG (ScsiCmd, SCSI_CMD_PDU_FLAG_READ | SCSI_CMD_PDU_FLAG_WRITE);
    2216     ScsiCmd->ExpDataXferLength = NTOHL (Packet->OutTransferLength);
    2217 
    2218     //
    2219     // Fill the bidirectional expected read data length AHS.
    2220     //
    2221     BiExpReadDataLenAHS                     = (ISCSI_BI_EXP_READ_DATA_LEN_AHS *) Header;
    2222     Header = (ISCSI_ADDITIONAL_HEADER *) (BiExpReadDataLenAHS + 1);
    2223 
    2224     BiExpReadDataLenAHS->Length = NTOHS (5);
    2225     BiExpReadDataLenAHS->Type = ISCSI_AHS_TYPE_BI_EXP_READ_DATA_LEN;
    2226     BiExpReadDataLenAHS->ExpReadDataLength = NTOHL (Packet->InTransferLength);
    2227 
    2228     break;
     2226    case DataIn:
     2227      ISCSI_SET_FLAG (ScsiCmd, SCSI_CMD_PDU_FLAG_READ);
     2228      ScsiCmd->ExpDataXferLength = NTOHL (Packet->InTransferLength);
     2229      break;
     2230
     2231    case DataOut:
     2232      ISCSI_SET_FLAG (ScsiCmd, SCSI_CMD_PDU_FLAG_WRITE);
     2233      ScsiCmd->ExpDataXferLength = NTOHL (Packet->OutTransferLength);
     2234      break;
     2235
     2236    case DataBi:
     2237      ISCSI_SET_FLAG (ScsiCmd, SCSI_CMD_PDU_FLAG_READ | SCSI_CMD_PDU_FLAG_WRITE);
     2238      ScsiCmd->ExpDataXferLength = NTOHL (Packet->OutTransferLength);
     2239
     2240      //
     2241      // Fill the bidirectional expected read data length AHS.
     2242      //
     2243      BiExpReadDataLenAHS = (ISCSI_BI_EXP_READ_DATA_LEN_AHS *)Header;
     2244      Header              = (ISCSI_ADDITIONAL_HEADER *)(BiExpReadDataLenAHS + 1);
     2245
     2246      BiExpReadDataLenAHS->Length            = NTOHS (5);
     2247      BiExpReadDataLenAHS->Type              = ISCSI_AHS_TYPE_BI_EXP_READ_DATA_LEN;
     2248      BiExpReadDataLenAHS->ExpReadDataLength = NTOHL (Packet->InTransferLength);
     2249
     2250      break;
    22292251  }
    22302252
    … …  
    22382260
    22392261  if (Packet->CdbLength > 16) {
    2240     Header->Length  = NTOHS ((UINT16) (Packet->CdbLength - 15));
    2241     Header->Type    = ISCSI_AHS_TYPE_EXT_CDB;
    2242 
    2243     CopyMem (Header + 1, (UINT8 *) Packet->Cdb + 16, Packet->CdbLength - 16);
    2244   }
    2245 
    2246   Pdu               = PduHeader;
    2247   Session           = Tcb->Conn->Session;
    2248   ImmediateDataLen  = 0;
     2262    Header->Length = NTOHS ((UINT16)(Packet->CdbLength - 15));
     2263    Header->Type   = ISCSI_AHS_TYPE_EXT_CDB;
     2264
     2265    CopyMem (Header + 1, (UINT8 *)Packet->Cdb + 16, Packet->CdbLength - 16);
     2266  }
     2267
     2268  Pdu              = PduHeader;
     2269  Session          = Tcb->Conn->Session;
     2270  ImmediateDataLen = 0;
    22492271
    22502272  if (Session->ImmediateData && (Packet->OutTransferLength != 0)) {
    … …  
    22542276    // the MaxRecvdataSegmentLength on this connection.
    22552277    //
    2256     ImmediateDataLen  = MIN (Session->FirstBurstLength, Packet->OutTransferLength);
    2257     ImmediateDataLen  = MIN (ImmediateDataLen, Tcb->Conn->MaxRecvDataSegmentLength);
     2278    ImmediateDataLen = MIN (Session->FirstBurstLength, Packet->OutTransferLength);
     2279    ImmediateDataLen = MIN (ImmediateDataLen, Tcb->Conn->MaxRecvDataSegmentLength);
    22582280
    22592281    //
    … …  
    22652287    // Create the data segment.
    22662288    //
    2267     DataSeg = IScsiNewDataSegment ((UINT8 *) Packet->OutDataBuffer, ImmediateDataLen, FALSE);
     2289    DataSeg = IScsiNewDataSegment ((UINT8 *)Packet->OutDataBuffer, ImmediateDataLen, FALSE);
    22682290    if (DataSeg == NULL) {
    22692291      NetbufFree (PduHeader);
    … …  
    22942316      (ImmediateDataLen == Session->FirstBurstLength) ||
    22952317      (ImmediateDataLen == Packet->OutTransferLength)
    2296       ) {
     2318      )
     2319  {
    22972320    //
    22982321    // Unsolicited data out sequence is not allowed,
    … …  
    23092332  return Pdu;
    23102333}
    2311 
    23122334
    23132335/**
    … …  
    23332355  )
    23342356{
    2335   LIST_ENTRY          *NbufList;
    2336   NET_BUF             *PduHdr;
    2337   NET_BUF             *DataSeg;
    2338   NET_BUF             *Pdu;
    2339   ISCSI_SCSI_DATA_OUT *DataOutHdr;
    2340   ISCSI_XFER_CONTEXT  *XferContext;
     2357  LIST_ENTRY           *NbufList;
     2358  NET_BUF              *PduHdr;
     2359  NET_BUF              *DataSeg;
     2360  NET_BUF              *Pdu;
     2361  ISCSI_SCSI_DATA_OUT  *DataOutHdr;
     2362  ISCSI_XFER_CONTEXT   *XferContext;
    23412363
    23422364  NbufList = AllocatePool (sizeof (LIST_ENTRY));
    … …  
    23552377    return NULL;
    23562378  }
     2379
    23572380  //
    23582381  // Insert the BHS into the buffer list.
    … …  
    23602383  InsertTailList (NbufList, &PduHdr->List);
    23612384
    2362   DataOutHdr  = (ISCSI_SCSI_DATA_OUT *) NetbufAllocSpace (PduHdr, sizeof (ISCSI_SCSI_DATA_OUT), NET_BUF_TAIL);
     2385  DataOutHdr = (ISCSI_SCSI_DATA_OUT *)NetbufAllocSpace (PduHdr, sizeof (ISCSI_SCSI_DATA_OUT), NET_BUF_TAIL);
    23632386  if (DataOutHdr == NULL) {
    23642387    IScsiFreeNbufList (NbufList);
    23652388    return NULL;
    23662389  }
     2390
    23672391  XferContext = &Tcb->XferContext;
    23682392
    … …  
    23842408    CopyMem (&DataOutHdr->Lun, &Lun, sizeof (DataOutHdr->Lun));
    23852409  }
     2410
    23862411  //
    23872412  // Build the data segment for this Data Out PDU.
    … …  
    23922417    return NULL;
    23932418  }
     2419
    23942420  //
    23952421  // Put the data segment into the buffer list and combine it with the BHS
    … …  
    24042430  return Pdu;
    24052431}
    2406 
    24072432
    24082433/**
    … …  
    24662491    // Update the context and DataSN.
    24672492    //
    2468     Data += DataLen;
    2469     XferContext->Offset += DataLen;
     2493    Data                       += DataLen;
     2494    XferContext->Offset        += DataLen;
    24702495    XferContext->DesiredLength -= DataLen;
    24712496    DataSN++;
    24722497  }
     2498
    24732499  //
    24742500  // Set the F bit for the last data out PDU in this sequence.
    … …  
    25072533  )
    25082534{
    2509   LIST_ENTRY      *DataOutPduList;
    2510   LIST_ENTRY      *Entry;
    2511   NET_BUF         *Pdu;
    2512   EFI_STATUS      Status;
     2535  LIST_ENTRY  *DataOutPduList;
     2536  LIST_ENTRY  *Entry;
     2537  NET_BUF     *Pdu;
     2538  EFI_STATUS  Status;
    25132539
    25142540  //
    … …  
    25262552  //
    25272553  NET_LIST_FOR_EACH (Entry, DataOutPduList) {
    2528     Pdu     = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);
     2554    Pdu = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);
    25292555
    25302556    Status = TcpIoTransmit (&Tcb->Conn->TcpIo, Pdu);
    … …  
    25392565  return Status;
    25402566}
    2541 
    25422567
    25432568/**
    … …  
    25652590  EFI_STATUS          Status;
    25662591
    2567   DataInHdr                   = (ISCSI_SCSI_DATA_IN *) NetbufGetByte (Pdu, 0, NULL);
     2592  DataInHdr = (ISCSI_SCSI_DATA_IN *)NetbufGetByte (Pdu, 0, NULL);
    25682593  if (DataInHdr == NULL) {
    25692594    return EFI_PROTOCOL_ERROR;
    … …  
    25862611    return EFI_PROTOCOL_ERROR;
    25872612  }
     2613
    25882614  //
    25892615  // Update the command related sequence numbers.
    … …  
    26072633      return EFI_PROTOCOL_ERROR;
    26082634    }
     2635
    26092636    //
    26102637    // S bit is on, the StatSN is valid.
    … …  
    26202647    if (ISCSI_FLAG_ON (DataInHdr, SCSI_RSP_PDU_FLAG_OVERFLOW)) {
    26212648      Packet->InTransferLength += NTOHL (DataInHdr->ResidualCount);
    2622       Status = EFI_BAD_BUFFER_SIZE;
     2649      Status                    = EFI_BAD_BUFFER_SIZE;
    26232650    }
    26242651
    … …  
    26302657  return Status;
    26312658}
    2632 
    26332659
    26342660/**
    … …  
    26532679  )
    26542680{
    2655   ISCSI_READY_TO_TRANSFER *R2THdr;
    2656   EFI_STATUS              Status;
    2657   ISCSI_XFER_CONTEXT      *XferContext;
    2658   UINT8                   *Data;
    2659 
    2660   R2THdr = (ISCSI_READY_TO_TRANSFER *) NetbufGetByte (Pdu, 0, NULL);
     2681  ISCSI_READY_TO_TRANSFER  *R2THdr;
     2682  EFI_STATUS               Status;
     2683  ISCSI_XFER_CONTEXT       *XferContext;
     2684  UINT8                    *Data;
     2685
     2686  R2THdr = (ISCSI_READY_TO_TRANSFER *)NetbufGetByte (Pdu, 0, NULL);
    26612687  if (R2THdr == NULL) {
    26622688    return EFI_PROTOCOL_ERROR;
    26632689  }
    26642690
    2665   R2THdr->InitiatorTaskTag = NTOHL (R2THdr->InitiatorTaskTag);
    2666   R2THdr->TargetTransferTag = NTOHL (R2THdr->TargetTransferTag);
    2667   R2THdr->StatSN = NTOHL (R2THdr->StatSN);
    2668   R2THdr->R2TSeqNum = NTOHL (R2THdr->R2TSeqNum);
    2669   R2THdr->BufferOffset = NTOHL (R2THdr->BufferOffset);
     2691  R2THdr->InitiatorTaskTag          = NTOHL (R2THdr->InitiatorTaskTag);
     2692  R2THdr->TargetTransferTag         = NTOHL (R2THdr->TargetTransferTag);
     2693  R2THdr->StatSN                    = NTOHL (R2THdr->StatSN);
     2694  R2THdr->R2TSeqNum                 = NTOHL (R2THdr->R2TSeqNum);
     2695  R2THdr->BufferOffset              = NTOHL (R2THdr->BufferOffset);
    26702696  R2THdr->DesiredDataTransferLength = NTOHL (R2THdr->DesiredDataTransferLength);
    26712697
    26722698  if ((R2THdr->InitiatorTaskTag != Tcb->InitiatorTaskTag) || !ISCSI_SEQ_EQ (R2THdr->StatSN, Tcb->Conn->ExpStatSN)) {
    2673     return EFI_PROTOCOL_ERROR;;
    2674   }
     2699    return EFI_PROTOCOL_ERROR;
     2700  }
     2701
    26752702  //
    26762703  // Check the sequence number.
    … …  
    26812708  }
    26822709
    2683   XferContext                     = &Tcb->XferContext;
    2684   XferContext->TargetTransferTag  = R2THdr->TargetTransferTag;
    2685   XferContext->Offset             = R2THdr->BufferOffset;
    2686   XferContext->DesiredLength      = R2THdr->DesiredDataTransferLength;
     2710  XferContext                    = &Tcb->XferContext;
     2711  XferContext->TargetTransferTag = R2THdr->TargetTransferTag;
     2712  XferContext->Offset            = R2THdr->BufferOffset;
     2713  XferContext->DesiredLength     = R2THdr->DesiredDataTransferLength;
    26872714
    26882715  if (((XferContext->Offset + XferContext->DesiredLength) > Packet->OutTransferLength) ||
    26892716      (XferContext->DesiredLength > Tcb->Conn->Session->MaxBurstLength)
    2690       ) {
     2717      )
     2718  {
    26912719    return EFI_PROTOCOL_ERROR;
    26922720  }
     2721
    26932722  //
    26942723  // Send the data solicited by this R2T.
    26952724  //
    2696   Data    = (UINT8 *) Packet->OutDataBuffer + XferContext->Offset;
    2697   Status  = IScsiSendDataOutPduSequence (Data, Lun, Tcb);
     2725  Data   = (UINT8 *)Packet->OutDataBuffer + XferContext->Offset;
     2726  Status = IScsiSendDataOutPduSequence (Data, Lun, Tcb);
    26982727
    26992728  return Status;
    27002729}
    2701 
    27022730
    27032731/**
    … …  
    27262754  UINT32            DataSegLen;
    27272755
    2728   ScsiRspHdr                    = (SCSI_RESPONSE *) NetbufGetByte (Pdu, 0, NULL);
     2756  ScsiRspHdr = (SCSI_RESPONSE *)NetbufGetByte (Pdu, 0, NULL);
    27292757  if (ScsiRspHdr == NULL) {
    27302758    return EFI_PROTOCOL_ERROR;
    27312759  }
    27322760
    2733   ScsiRspHdr->InitiatorTaskTag  = NTOHL (ScsiRspHdr->InitiatorTaskTag);
     2761  ScsiRspHdr->InitiatorTaskTag = NTOHL (ScsiRspHdr->InitiatorTaskTag);
    27342762  if (ScsiRspHdr->InitiatorTaskTag != Tcb->InitiatorTaskTag) {
    27352763    return EFI_PROTOCOL_ERROR;
    27362764  }
    27372765
    2738   ScsiRspHdr->StatSN  = NTOHL (ScsiRspHdr->StatSN);
    2739 
    2740   Status              = IScsiCheckSN (&Tcb->Conn->ExpStatSN, ScsiRspHdr->StatSN);
     2766  ScsiRspHdr->StatSN = NTOHL (ScsiRspHdr->StatSN);
     2767
     2768  Status = IScsiCheckSN (&Tcb->Conn->ExpStatSN, ScsiRspHdr->StatSN);
    27412769  if (EFI_ERROR (Status)) {
    27422770    return Status;
    27432771  }
    27442772
    2745   ScsiRspHdr->MaxCmdSN  = NTOHL (ScsiRspHdr->MaxCmdSN);
    2746   ScsiRspHdr->ExpCmdSN  = NTOHL (ScsiRspHdr->ExpCmdSN);
     2773  ScsiRspHdr->MaxCmdSN = NTOHL (ScsiRspHdr->MaxCmdSN);
     2774  ScsiRspHdr->ExpCmdSN = NTOHL (ScsiRspHdr->ExpCmdSN);
    27472775  IScsiUpdateCmdSN (Tcb->Conn->Session, ScsiRspHdr->MaxCmdSN, ScsiRspHdr->ExpCmdSN);
    27482776
    2749   Tcb->StatusXferd          = TRUE;
     2777  Tcb->StatusXferd = TRUE;
    27502778
    27512779  Packet->HostAdapterStatus = ScsiRspHdr->Response;
    … …  
    27582786  if (ISCSI_FLAG_ON (ScsiRspHdr, SCSI_RSP_PDU_FLAG_BI_READ_OVERFLOW | SCSI_RSP_PDU_FLAG_BI_READ_UNDERFLOW) ||
    27592787      ISCSI_FLAG_ON (ScsiRspHdr, SCSI_RSP_PDU_FLAG_OVERFLOW | SCSI_RSP_PDU_FLAG_UNDERFLOW)
    2760         ) {
     2788      )
     2789  {
    27612790    return EFI_PROTOCOL_ERROR;
    27622791  }
    … …  
    27642793  if (ISCSI_FLAG_ON (ScsiRspHdr, SCSI_RSP_PDU_FLAG_BI_READ_OVERFLOW)) {
    27652794    Packet->InTransferLength += NTOHL (ScsiRspHdr->BiReadResidualCount);
    2766     Status = EFI_BAD_BUFFER_SIZE;
     2795    Status                    = EFI_BAD_BUFFER_SIZE;
    27672796  }
    27682797
    … …  
    27912820  DataSegLen = ISCSI_GET_DATASEG_LEN (ScsiRspHdr);
    27922821  if (DataSegLen != 0) {
    2793     SenseData               = (ISCSI_SENSE_DATA *) NetbufGetByte (Pdu, sizeof (SCSI_RESPONSE), NULL);
     2822    SenseData = (ISCSI_SENSE_DATA *)NetbufGetByte (Pdu, sizeof (SCSI_RESPONSE), NULL);
    27942823    if (SenseData == NULL) {
    27952824      return EFI_PROTOCOL_ERROR;
    27962825    }
    27972826
    2798     SenseData->Length       = NTOHS (SenseData->Length);
    2799 
    2800     Packet->SenseDataLength = (UINT8) MIN (SenseData->Length, Packet->SenseDataLength);
     2827    SenseData->Length = NTOHS (SenseData->Length);
     2828
     2829    Packet->SenseDataLength = (UINT8)MIN (SenseData->Length, Packet->SenseDataLength);
    28012830    if (Packet->SenseDataLength != 0) {
    28022831      CopyMem (Packet->SenseData, &SenseData->Data[0], Packet->SenseDataLength);
    … …  
    28082837  return Status;
    28092838}
    2810 
    28112839
    28122840/**
    … …  
    28302858  EFI_STATUS    Status;
    28312859
    2832   NopInHdr            = (ISCSI_NOP_IN *) NetbufGetByte (Pdu, 0, NULL);
     2860  NopInHdr = (ISCSI_NOP_IN *)NetbufGetByte (Pdu, 0, NULL);
    28332861  if (NopInHdr == NULL) {
    28342862    return EFI_PROTOCOL_ERROR;
    28352863  }
    28362864
    2837   NopInHdr->StatSN    = NTOHL (NopInHdr->StatSN);
    2838   NopInHdr->ExpCmdSN  = NTOHL (NopInHdr->ExpCmdSN);
    2839   NopInHdr->MaxCmdSN  = NTOHL (NopInHdr->MaxCmdSN);
     2865  NopInHdr->StatSN   = NTOHL (NopInHdr->StatSN);
     2866  NopInHdr->ExpCmdSN = NTOHL (NopInHdr->ExpCmdSN);
     2867  NopInHdr->MaxCmdSN = NTOHL (NopInHdr->MaxCmdSN);
    28402868
    28412869  if (NopInHdr->InitiatorTaskTag == ISCSI_RESERVED_TAG) {
    … …  
    28542882  return EFI_SUCCESS;
    28552883}
    2856 
    28572884
    28582885/**
    … …  
    28822909  )
    28832910{
    2884   EFI_STATUS              Status;
    2885   ISCSI_DRIVER_DATA       *Private;
    2886   ISCSI_SESSION           *Session;
    2887   EFI_EVENT               TimeoutEvent;
    2888   ISCSI_CONNECTION        *Conn;
    2889   ISCSI_TCB               *Tcb;
    2890   NET_BUF                 *Pdu;
    2891   ISCSI_XFER_CONTEXT      *XferContext;
    2892   UINT8                   *Data;
    2893   ISCSI_IN_BUFFER_CONTEXT InBufferContext;
    2894   UINT64                  Timeout;
    2895   UINT8                   *PduHdr;
    2896 
    2897   Private       = ISCSI_DRIVER_DATA_FROM_EXT_SCSI_PASS_THRU (PassThru);
    2898   Session       = Private->Session;
    2899   Status        = EFI_SUCCESS;
    2900   Tcb           = NULL;
    2901   TimeoutEvent  = NULL;
    2902   Timeout       = 0;
     2911  EFI_STATUS               Status;
     2912  ISCSI_DRIVER_DATA        *Private;
     2913  ISCSI_SESSION            *Session;
     2914  EFI_EVENT                TimeoutEvent;
     2915  ISCSI_CONNECTION         *Conn;
     2916  ISCSI_TCB                *Tcb;
     2917  NET_BUF                  *Pdu;
     2918  ISCSI_XFER_CONTEXT       *XferContext;
     2919  UINT8                    *Data;
     2920  ISCSI_IN_BUFFER_CONTEXT  InBufferContext;
     2921  UINT64                   Timeout;
     2922  UINT8                    *PduHdr;
     2923
     2924  Private      = ISCSI_DRIVER_DATA_FROM_EXT_SCSI_PASS_THRU (PassThru);
     2925  Session      = Private->Session;
     2926  Status       = EFI_SUCCESS;
     2927  Tcb          = NULL;
     2928  TimeoutEvent = NULL;
     2929  Timeout      = 0;
    29032930
    29042931  if (Session->State != SESSION_STATE_LOGGED_IN) {
    … …  
    29222949    goto ON_EXIT;
    29232950  }
     2951
    29242952  //
    29252953  // Encapsulate the SCSI request packet into an iSCSI SCSI Command PDU.
    … …  
    29312959  }
    29322960
    2933   XferContext         = &Tcb->XferContext;
    2934   PduHdr              = NetbufGetByte (Pdu, 0, NULL);
     2961  XferContext = &Tcb->XferContext;
     2962  PduHdr      = NetbufGetByte (Pdu, 0, NULL);
    29352963  if (PduHdr == NULL) {
    29362964    Status = EFI_PROTOCOL_ERROR;
    … …  
    29382966    goto ON_EXIT;
    29392967  }
     2968
    29402969  XferContext->Offset = ISCSI_GET_DATASEG_LEN (PduHdr);
    29412970
    … …  
    29542983      (XferContext->Offset < Session->FirstBurstLength) &&
    29552984      (XferContext->Offset < Packet->OutTransferLength)
    2956       ) {
     2985      )
     2986  {
    29572987    //
    29582988    // Unsolicited Data-Out sequence is allowed. There is remaining SCSI
    … …  
    29602990    //
    29612991    XferContext->TargetTransferTag = ISCSI_RESERVED_TAG;
    2962     XferContext->DesiredLength = MIN (
    2963                                    Session->FirstBurstLength,
    2964                                    Packet->OutTransferLength - XferContext->Offset
    2965                                    );
    2966 
    2967     Data    = (UINT8 *) Packet->OutDataBuffer + XferContext->Offset;
    2968     Status  = IScsiSendDataOutPduSequence (Data, Lun, Tcb);
     2992    XferContext->DesiredLength     = MIN (
     2993                                       Session->FirstBurstLength,
     2994                                       Packet->OutTransferLength - XferContext->Offset
     2995                                       );
     2996
     2997    Data   = (UINT8 *)Packet->OutDataBuffer + XferContext->Offset;
     2998    Status = IScsiSendDataOutPduSequence (Data, Lun, Tcb);
    29692999    if (EFI_ERROR (Status)) {
    29703000      goto ON_EXIT;
    … …  
    29723002  }
    29733003
    2974   InBufferContext.InData    = (UINT8 *) Packet->InDataBuffer;
     3004  InBufferContext.InData    = (UINT8 *)Packet->InDataBuffer;
    29753005  InBufferContext.InDataLen = Packet->InTransferLength;
    29763006
    … …  
    30023032      goto ON_EXIT;
    30033033    }
     3034
    30043035    switch (ISCSI_GET_OPCODE (PduHdr)) {
    3005     case ISCSI_OPCODE_SCSI_DATA_IN:
    3006       Status = IScsiOnDataInRcvd (Pdu, Tcb, Packet);
    3007       break;
    3008 
    3009     case ISCSI_OPCODE_R2T:
    3010       Status = IScsiOnR2TRcvd (Pdu, Tcb, Lun, Packet);
    3011       break;
    3012 
    3013     case ISCSI_OPCODE_SCSI_RSP:
    3014       Status = IScsiOnScsiRspRcvd (Pdu, Tcb, Packet);
    3015       break;
    3016 
    3017     case ISCSI_OPCODE_NOP_IN:
    3018       Status = IScsiOnNopInRcvd (Pdu, Tcb);
    3019       break;
    3020 
    3021     case ISCSI_OPCODE_VENDOR_T0:
    3022     case ISCSI_OPCODE_VENDOR_T1:
    3023     case ISCSI_OPCODE_VENDOR_T2:
    3024       //
    3025       // These messages are vendor specific. Skip them.
    3026       //
    3027       break;
    3028 
    3029     default:
    3030       Status = EFI_PROTOCOL_ERROR;
    3031       break;
     3036      case ISCSI_OPCODE_SCSI_DATA_IN:
     3037        Status = IScsiOnDataInRcvd (Pdu, Tcb, Packet);
     3038        break;
     3039
     3040      case ISCSI_OPCODE_R2T:
     3041        Status = IScsiOnR2TRcvd (Pdu, Tcb, Lun, Packet);
     3042        break;
     3043
     3044      case ISCSI_OPCODE_SCSI_RSP:
     3045        Status = IScsiOnScsiRspRcvd (Pdu, Tcb, Packet);
     3046        break;
     3047
     3048      case ISCSI_OPCODE_NOP_IN:
     3049        Status = IScsiOnNopInRcvd (Pdu, Tcb);
     3050        break;
     3051
     3052      case ISCSI_OPCODE_VENDOR_T0:
     3053      case ISCSI_OPCODE_VENDOR_T1:
     3054      case ISCSI_OPCODE_VENDOR_T2:
     3055        //
     3056        // These messages are vendor specific. Skip them.
     3057        //
     3058        break;
     3059
     3060      default:
     3061        Status = EFI_PROTOCOL_ERROR;
     3062        break;
    30323063    }
    30333064
    … …  
    30513082  return Status;
    30523083}
    3053 
    30543084
    30553085/**
    … …  
    30673097  )
    30683098{
    3069   EFI_STATUS    Status;
     3099  EFI_STATUS  Status;
    30703100
    30713101  ASSERT (Session->State != SESSION_STATE_FREE);
    … …  
    30843114  return Status;
    30853115}
    3086 
    30873116
    30883117/**
    … …  
    31003129{
    31013130  if (!Recovery) {
    3102     Session->Signature  = ISCSI_SESSION_SIGNATURE;
    3103     Session->State      = SESSION_STATE_FREE;
     3131    Session->Signature = ISCSI_SESSION_SIGNATURE;
     3132    Session->State     = SESSION_STATE_FREE;
    31043133
    31053134    InitializeListHead (&Session->Conns);
    … …  
    31073136  }
    31083137
    3109   Session->Tsih                 = 0;
    3110 
    3111   Session->CmdSN                = 1;
    3112   Session->InitiatorTaskTag     = 1;
    3113   Session->NextCid              = 1;
     3138  Session->Tsih = 0;
     3139
     3140  Session->CmdSN            = 1;
     3141  Session->InitiatorTaskTag = 1;
     3142  Session->NextCid          = 1;
    31143143
    31153144  Session->TargetPortalGroupTag = 0;
    … …  
    31273156}
    31283157
    3129 
    31303158/**
    31313159  Abort the iSCSI session. That is, reset all the connection(s), and free the
    … …  
    31443172
    31453173  if (Session->State != SESSION_STATE_LOGGED_IN) {
    3146     return ;
     3174    return;
    31473175  }
    31483176
    … …  
    31773205  Session->State = SESSION_STATE_FAILED;
    31783206
    3179   return ;
    3180 }
     3207  return;
     3208}
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette