lib/libefivar/uefi-dputil.c

   1 /*-
   2  * Copyright (c) 2017 Netflix, Inc.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer
  10  *    in this position and unchanged.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 /*
  28  * Routines to format EFI_DEVICE_PATHs from the UEFI standard. Much of
  29  * this file is taken from EDK2 and rototilled.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __FBSDID("$FreeBSD$");
  34
  35 #include <efivar.h>
  36 #include <limits.h>
  37 #include <stdio.h>
  38 #include <string.h>
  39 #include <sys/endian.h>
  40
  41 #include "efi-osdep.h"
  42
  43 #include "uefi-dplib.h"
  44
  45 /* XXX maybe I should include the entire DevicePathUtiltiies.c and ifdef out what we don't use */
  46
  47 /*
  48  * Taken from MdePkg/Library/UefiDevicePathLib/DevicePathUtilities.c
  49  * hash a11928f3310518ab1c6fd34e8d0fdbb72de9602c 2017-Mar-01
  50  */
  51
  52 /** @file
  53   Device Path services. The thing to remember is device paths are built out of
  54   nodes. The device path is terminated by an end node that is length
  55   sizeof(EFI_DEVICE_PATH_PROTOCOL). That would be why there is sizeof(EFI_DEVICE_PATH_PROTOCOL)
  56   all over this file.
  57
  58   The only place where multi-instance device paths are supported is in
  59   environment varibles. Multi-instance device paths should never be placed
  60   on a Handle.
  61
  62   Copyright (c) 2006 - 2016, Intel Corporation. All rights reserved.<BR>
  63   This program and the accompanying materials
  64   are licensed and made available under the terms and conditions of the BSD License
  65   which accompanies this distribution.  The full text of the license may be found at
  66   http://opensource.org/licenses/bsd-license.php.
  67
  68   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  69   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  70
  71 **/
  72
  73 //
  74 // Template for an end-of-device path node.
  75 //
  76 static CONST EFI_DEVICE_PATH_PROTOCOL  mUefiDevicePathLibEndDevicePath = {
  77   END_DEVICE_PATH_TYPE,
  78   END_ENTIRE_DEVICE_PATH_SUBTYPE,
  79   {
  80     END_DEVICE_PATH_LENGTH,
  81     0
  82   }
  83 };
  84
  85
  86 /**
  87   Returns the size of a device path in bytes.
  88
  89   This function returns the size, in bytes, of the device path data structure
  90   specified by DevicePath including the end of device path node.
  91   If DevicePath is NULL or invalid, then 0 is returned.
  92
  93   @param  DevicePath  A pointer to a device path data structure.
  94
  95   @retval 0           If DevicePath is NULL or invalid.
  96   @retval Others      The size of a device path in bytes.
  97
  98 **/
  99 UINTN
 100 EFIAPI
 101 GetDevicePathSize (
 102   IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath
 103   )
 104 {
 105   CONST EFI_DEVICE_PATH_PROTOCOL  *Start;
 106
 107   if (DevicePath == NULL) {
 108     return 0;
 109   }
 110
 111   if (!IsDevicePathValid (DevicePath, 0)) {
 112     return 0;
 113   }
 114
 115   //
 116   // Search for the end of the device path structure
 117   //
 118   Start = DevicePath;
 119   while (!IsDevicePathEnd (DevicePath)) {
 120     DevicePath = NextDevicePathNode (DevicePath);
 121   }
 122
 123   //
 124   // Compute the size and add back in the size of the end device path structure
 125   //
 126   return ((UINTN) DevicePath - (UINTN) Start) + DevicePathNodeLength (DevicePath);
 127 }
 128
 129 /**
 130   Determine whether a given device path is valid.
 131   If DevicePath is NULL, then ASSERT().
 132
 133   @param  DevicePath  A pointer to a device path data structure.
 134   @param  MaxSize     The maximum size of the device path data structure.
 135
 136   @retval TRUE        DevicePath is valid.
 137   @retval FALSE       The length of any node in the DevicePath is less
 138                       than sizeof (EFI_DEVICE_PATH_PROTOCOL).
 139   @retval FALSE       If MaxSize is not zero, the size of the DevicePath
 140                       exceeds MaxSize.
 141   @retval FALSE       If PcdMaximumDevicePathNodeCount is not zero, the node
 142                       count of the DevicePath exceeds PcdMaximumDevicePathNodeCount.
 143 **/
 144 BOOLEAN
 145 EFIAPI
 146 IsDevicePathValid (
 147   IN CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath,
 148   IN       UINTN                    MaxSize
 149   )
 150 {
 151   UINTN Count;
 152   UINTN Size;
 153   UINTN NodeLength;
 154
 155   ASSERT (DevicePath != NULL);
 156
 157   if (MaxSize == 0) {
 158     MaxSize = MAX_UINTN;
 159   }
 160
 161   //
 162   // Validate the input size big enough to touch the first node.
 163   //
 164   if (MaxSize < sizeof (EFI_DEVICE_PATH_PROTOCOL)) {
 165     return FALSE;
 166   }
 167
 168   for (Count = 0, Size = 0; !IsDevicePathEnd (DevicePath); DevicePath = NextDevicePathNode (DevicePath)) {
 169     NodeLength = DevicePathNodeLength (DevicePath);
 170     if (NodeLength < sizeof (EFI_DEVICE_PATH_PROTOCOL)) {
 171       return FALSE;
 172     }
 173
 174     if (NodeLength > MAX_UINTN - Size) {
 175       return FALSE;
 176     }
 177     Size += NodeLength;
 178
 179     //
 180     // Validate next node before touch it.
 181     //
 182     if (Size > MaxSize - END_DEVICE_PATH_LENGTH ) {
 183       return FALSE;
 184     }
 185
 186     if (PcdGet32 (PcdMaximumDevicePathNodeCount) > 0) {
 187       Count++;
 188       if (Count >= PcdGet32 (PcdMaximumDevicePathNodeCount)) {
 189         return FALSE;
 190       }
 191     }
 192   }
 193
 194   //
 195   // Only return TRUE when the End Device Path node is valid.
 196   //
 197   return (BOOLEAN) (DevicePathNodeLength (DevicePath) == END_DEVICE_PATH_LENGTH);
 198 }
 199
 200 /**
 201   Returns the Type field of a device path node.
 202
 203   Returns the Type field of the device path node specified by Node.
 204
 205   If Node is NULL, then ASSERT().
 206
 207   @param  Node      A pointer to a device path node data structure.
 208
 209   @return The Type field of the device path node specified by Node.
 210
 211 **/
 212 UINT8
 213 EFIAPI
 214 DevicePathType (
 215   IN CONST VOID  *Node
 216   )
 217 {
 218   ASSERT (Node != NULL);
 219   return ((const EFI_DEVICE_PATH_PROTOCOL *)(Node))->Type;
 220 }
 221
 222
 223 /**
 224   Returns the SubType field of a device path node.
 225
 226   Returns the SubType field of the device path node specified by Node.
 227
 228   If Node is NULL, then ASSERT().
 229
 230   @param  Node      A pointer to a device path node data structure.
 231
 232   @return The SubType field of the device path node specified by Node.
 233
 234 **/
 235 UINT8
 236 EFIAPI
 237 DevicePathSubType (
 238   IN CONST VOID  *Node
 239   )
 240 {
 241   ASSERT (Node != NULL);
 242   return ((const EFI_DEVICE_PATH_PROTOCOL *)(Node))->SubType;
 243 }
 244
 245 /**
 246   Returns the 16-bit Length field of a device path node.
 247
 248   Returns the 16-bit Length field of the device path node specified by Node.
 249   Node is not required to be aligned on a 16-bit boundary, so it is recommended
 250   that a function such as ReadUnaligned16() be used to extract the contents of
 251   the Length field.
 252
 253   If Node is NULL, then ASSERT().
 254
 255   @param  Node      A pointer to a device path node data structure.
 256
 257   @return The 16-bit Length field of the device path node specified by Node.
 258
 259 **/
 260 UINTN
 261 EFIAPI
 262 DevicePathNodeLength (
 263   IN CONST VOID  *Node
 264   )
 265 {
 266   ASSERT (Node != NULL);
 267   return ((const EFI_DEVICE_PATH_PROTOCOL *)Node)->Length[0] |
 268       (((const EFI_DEVICE_PATH_PROTOCOL *)Node)->Length[1] << 8);
 269 }
 270
 271 /**
 272   Returns a pointer to the next node in a device path.
 273
 274   Returns a pointer to the device path node that follows the device path node
 275   specified by Node.
 276
 277   If Node is NULL, then ASSERT().
 278
 279   @param  Node      A pointer to a device path node data structure.
 280
 281   @return a pointer to the device path node that follows the device path node
 282   specified by Node.
 283
 284 **/
 285 EFI_DEVICE_PATH_PROTOCOL *
 286 EFIAPI
 287 NextDevicePathNode (
 288   IN CONST VOID  *Node
 289   )
 290 {
 291   ASSERT (Node != NULL);
 292   return ((EFI_DEVICE_PATH_PROTOCOL *)(__DECONST(UINT8 *, Node) + DevicePathNodeLength(Node)));
 293 }
 294
 295 /**
 296   Determines if a device path node is an end node of a device path.
 297   This includes nodes that are the end of a device path instance and nodes that
 298   are the end of an entire device path.
 299
 300   Determines if the device path node specified by Node is an end node of a device path.
 301   This includes nodes that are the end of a device path instance and nodes that are the
 302   end of an entire device path.  If Node represents an end node of a device path,
 303   then TRUE is returned.  Otherwise, FALSE is returned.
 304
 305   If Node is NULL, then ASSERT().
 306
 307   @param  Node      A pointer to a device path node data structure.
 308
 309   @retval TRUE      The device path node specified by Node is an end node of a
 310                     device path.
 311   @retval FALSE     The device path node specified by Node is not an end node of
 312                     a device path.
 313
 314 **/
 315 BOOLEAN
 316 EFIAPI
 317 IsDevicePathEndType (
 318   IN CONST VOID  *Node
 319   )
 320 {
 321   ASSERT (Node != NULL);
 322   return (BOOLEAN) (DevicePathType (Node) == END_DEVICE_PATH_TYPE);
 323 }
 324
 325 /**
 326   Determines if a device path node is an end node of an entire device path.
 327
 328   Determines if a device path node specified by Node is an end node of an entire
 329   device path. If Node represents the end of an entire device path, then TRUE is
 330   returned.  Otherwise, FALSE is returned.
 331
 332   If Node is NULL, then ASSERT().
 333
 334   @param  Node      A pointer to a device path node data structure.
 335
 336   @retval TRUE      The device path node specified by Node is the end of an entire
 337                     device path.
 338   @retval FALSE     The device path node specified by Node is not the end of an
 339                     entire device path.
 340
 341 **/
 342 BOOLEAN
 343 EFIAPI
 344 IsDevicePathEnd (
 345   IN CONST VOID  *Node
 346   )
 347 {
 348   ASSERT (Node != NULL);
 349   return (BOOLEAN) (IsDevicePathEndType (Node) && DevicePathSubType(Node) == END_ENTIRE_DEVICE_PATH_SUBTYPE);
 350 }
 351
 352 /**
 353   Fills in all the fields of a device path node that is the end of an entire device path.
 354
 355   Fills in all the fields of a device path node specified by Node so Node represents
 356   the end of an entire device path.  The Type field of Node is set to
 357   END_DEVICE_PATH_TYPE, the SubType field of Node is set to
 358   END_ENTIRE_DEVICE_PATH_SUBTYPE, and the Length field of Node is set to
 359   END_DEVICE_PATH_LENGTH.  Node is not required to be aligned on a 16-bit boundary,
 360   so it is recommended that a function such as WriteUnaligned16() be used to set
 361   the contents of the Length field.
 362
 363   If Node is NULL, then ASSERT().
 364
 365   @param  Node      A pointer to a device path node data structure.
 366
 367 **/
 368 VOID
 369 EFIAPI
 370 SetDevicePathEndNode (
 371   OUT VOID  *Node
 372   )
 373 {
 374   ASSERT (Node != NULL);
 375   memcpy (Node, &mUefiDevicePathLibEndDevicePath, sizeof (mUefiDevicePathLibEndDevicePath));
 376 }
 377
 378 /**
 379   Sets the length, in bytes, of a device path node.
 380
 381   Sets the length of the device path node specified by Node to the value specified
 382   by NodeLength.  NodeLength is returned.  Node is not required to be aligned on
 383   a 16-bit boundary, so it is recommended that a function such as WriteUnaligned16()
 384   be used to set the contents of the Length field.
 385
 386   If Node is NULL, then ASSERT().
 387   If NodeLength >= SIZE_64KB, then ASSERT().
 388   If NodeLength < sizeof (EFI_DEVICE_PATH_PROTOCOL), then ASSERT().
 389
 390   @param  Node      A pointer to a device path node data structure.
 391   @param  Length    The length, in bytes, of the device path node.
 392
 393   @return Length
 394
 395 **/
 396 UINT16
 397 EFIAPI
 398 SetDevicePathNodeLength (
 399   IN OUT VOID  *Node,
 400   IN UINTN     Length
 401   )
 402 {
 403   ASSERT (Node != NULL);
 404   ASSERT ((Length >= sizeof (EFI_DEVICE_PATH_PROTOCOL)) && (Length < SIZE_64KB));
 405 //  return WriteUnaligned16 ((UINT16 *)&((EFI_DEVICE_PATH_PROTOCOL *)(Node))->Length[0], (UINT16)(Length));
 406   le16enc(&((EFI_DEVICE_PATH_PROTOCOL *)(Node))->Length[0], (UINT16)(Length));
 407   return Length;
 408 }
 409
 410 /**
 411   Creates a device node.
 412
 413   This function creates a new device node in a newly allocated buffer of size
 414   NodeLength and initializes the device path node header with NodeType and NodeSubType.
 415   The new device path node is returned.
 416   If NodeLength is smaller than a device path header, then NULL is returned.
 417   If there is not enough memory to allocate space for the new device path, then
 418   NULL is returned.
 419   The memory is allocated from EFI boot services memory. It is the responsibility
 420   of the caller to free the memory allocated.
 421
 422   @param  NodeType                   The device node type for the new device node.
 423   @param  NodeSubType                The device node sub-type for the new device node.
 424   @param  NodeLength                 The length of the new device node.
 425
 426   @return The new device path.
 427
 428 **/
 429 EFI_DEVICE_PATH_PROTOCOL *
 430 EFIAPI
 431 CreateDeviceNode (
 432   IN UINT8                           NodeType,
 433   IN UINT8                           NodeSubType,
 434   IN UINT16                          NodeLength
 435   )
 436 {
 437   EFI_DEVICE_PATH_PROTOCOL      *DevicePath;
 438
 439   if (NodeLength < sizeof (EFI_DEVICE_PATH_PROTOCOL)) {
 440     //
 441     // NodeLength is less than the size of the header.
 442     //
 443     return NULL;
 444   }
 445
 446   DevicePath = AllocateZeroPool (NodeLength);
 447   if (DevicePath != NULL) {
 448      DevicePath->Type    = NodeType;
 449      DevicePath->SubType = NodeSubType;
 450      SetDevicePathNodeLength (DevicePath, NodeLength);
 451   }
 452
 453   return DevicePath;
 454 }
 455
 456 /**
 457   Creates a new copy of an existing device path.
 458
 459   This function allocates space for a new copy of the device path specified by DevicePath.
 460   If DevicePath is NULL, then NULL is returned.  If the memory is successfully
 461   allocated, then the contents of DevicePath are copied to the newly allocated
 462   buffer, and a pointer to that buffer is returned.  Otherwise, NULL is returned.
 463   The memory for the new device path is allocated from EFI boot services memory.
 464   It is the responsibility of the caller to free the memory allocated.
 465
 466   @param  DevicePath    A pointer to a device path data structure.
 467
 468   @retval NULL          DevicePath is NULL or invalid.
 469   @retval Others        A pointer to the duplicated device path.
 470
 471 **/
 472 EFI_DEVICE_PATH_PROTOCOL *
 473 EFIAPI
 474 DuplicateDevicePath (
 475   IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath
 476   )
 477 {
 478   UINTN                     Size;
 479
 480   //
 481   // Compute the size
 482   //
 483   Size = GetDevicePathSize (DevicePath);
 484   if (Size == 0) {
 485     return NULL;
 486   }
 487
 488   //
 489   // Allocate space for duplicate device path
 490   //
 491
 492   return AllocateCopyPool (Size, DevicePath);
 493 }
 494
 495 /**
 496   Creates a new device path by appending a second device path to a first device path.
 497
 498   This function creates a new device path by appending a copy of SecondDevicePath
 499   to a copy of FirstDevicePath in a newly allocated buffer.  Only the end-of-device-path
 500   device node from SecondDevicePath is retained. The newly created device path is
 501   returned. If FirstDevicePath is NULL, then it is ignored, and a duplicate of
 502   SecondDevicePath is returned.  If SecondDevicePath is NULL, then it is ignored,
 503   and a duplicate of FirstDevicePath is returned. If both FirstDevicePath and
 504   SecondDevicePath are NULL, then a copy of an end-of-device-path is returned.
 505
 506   If there is not enough memory for the newly allocated buffer, then NULL is returned.
 507   The memory for the new device path is allocated from EFI boot services memory.
 508   It is the responsibility of the caller to free the memory allocated.
 509
 510   @param  FirstDevicePath            A pointer to a device path data structure.
 511   @param  SecondDevicePath           A pointer to a device path data structure.
 512
 513   @retval NULL      If there is not enough memory for the newly allocated buffer.
 514   @retval NULL      If FirstDevicePath or SecondDevicePath is invalid.
 515   @retval Others    A pointer to the new device path if success.
 516                     Or a copy an end-of-device-path if both FirstDevicePath and SecondDevicePath are NULL.
 517
 518 **/
 519 EFI_DEVICE_PATH_PROTOCOL *
 520 EFIAPI
 521 AppendDevicePath (
 522   IN CONST EFI_DEVICE_PATH_PROTOCOL  *FirstDevicePath,  OPTIONAL
 523   IN CONST EFI_DEVICE_PATH_PROTOCOL  *SecondDevicePath  OPTIONAL
 524   )
 525 {
 526   UINTN                     Size;
 527   UINTN                     Size1;
 528   UINTN                     Size2;
 529   EFI_DEVICE_PATH_PROTOCOL  *NewDevicePath;
 530   EFI_DEVICE_PATH_PROTOCOL  *DevicePath2;
 531
 532   //
 533   // If there's only 1 path, just duplicate it.
 534   //
 535   if (FirstDevicePath == NULL) {
 536     return DuplicateDevicePath ((SecondDevicePath != NULL) ? SecondDevicePath : &mUefiDevicePathLibEndDevicePath);
 537   }
 538
 539   if (SecondDevicePath == NULL) {
 540     return DuplicateDevicePath (FirstDevicePath);
 541   }
 542
 543   if (!IsDevicePathValid (FirstDevicePath, 0) || !IsDevicePathValid (SecondDevicePath, 0)) {
 544     return NULL;
 545   }
 546
 547   //
 548   // Allocate space for the combined device path. It only has one end node of
 549   // length EFI_DEVICE_PATH_PROTOCOL.
 550   //
 551   Size1         = GetDevicePathSize (FirstDevicePath);
 552   Size2         = GetDevicePathSize (SecondDevicePath);
 553   Size          = Size1 + Size2 - END_DEVICE_PATH_LENGTH;
 554
 555   NewDevicePath = AllocatePool (Size);
 556
 557   if (NewDevicePath != NULL) {
 558     NewDevicePath = CopyMem (NewDevicePath, FirstDevicePath, Size1);
 559     //
 560     // Over write FirstDevicePath EndNode and do the copy
 561     //
 562     DevicePath2 = (EFI_DEVICE_PATH_PROTOCOL *) ((CHAR8 *) NewDevicePath +
 563                   (Size1 - END_DEVICE_PATH_LENGTH));
 564     CopyMem (DevicePath2, SecondDevicePath, Size2);
 565   }
 566
 567   return NewDevicePath;
 568 }
 569
 570 /**
 571   Creates a new path by appending the device node to the device path.
 572
 573   This function creates a new device path by appending a copy of the device node
 574   specified by DevicePathNode to a copy of the device path specified by DevicePath
 575   in an allocated buffer. The end-of-device-path device node is moved after the
 576   end of the appended device node.
 577   If DevicePathNode is NULL then a copy of DevicePath is returned.
 578   If DevicePath is NULL then a copy of DevicePathNode, followed by an end-of-device
 579   path device node is returned.
 580   If both DevicePathNode and DevicePath are NULL then a copy of an end-of-device-path
 581   device node is returned.
 582   If there is not enough memory to allocate space for the new device path, then
 583   NULL is returned.
 584   The memory is allocated from EFI boot services memory. It is the responsibility
 585   of the caller to free the memory allocated.
 586
 587   @param  DevicePath                 A pointer to a device path data structure.
 588   @param  DevicePathNode             A pointer to a single device path node.
 589
 590   @retval NULL      If there is not enough memory for the new device path.
 591   @retval Others    A pointer to the new device path if success.
 592                     A copy of DevicePathNode followed by an end-of-device-path node
 593                     if both FirstDevicePath and SecondDevicePath are NULL.
 594                     A copy of an end-of-device-path node if both FirstDevicePath
 595                     and SecondDevicePath are NULL.
 596
 597 **/
 598 EFI_DEVICE_PATH_PROTOCOL *
 599 EFIAPI
 600 AppendDevicePathNode (
 601   IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath,     OPTIONAL
 602   IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePathNode  OPTIONAL
 603   )
 604 {
 605   EFI_DEVICE_PATH_PROTOCOL  *TempDevicePath;
 606   EFI_DEVICE_PATH_PROTOCOL  *NextNode;
 607   EFI_DEVICE_PATH_PROTOCOL  *NewDevicePath;
 608   UINTN                     NodeLength;
 609
 610   if (DevicePathNode == NULL) {
 611     return DuplicateDevicePath ((DevicePath != NULL) ? DevicePath : &mUefiDevicePathLibEndDevicePath);
 612   }
 613   //
 614   // Build a Node that has a terminator on it
 615   //
 616   NodeLength = DevicePathNodeLength (DevicePathNode);
 617
 618   TempDevicePath = AllocatePool (NodeLength + END_DEVICE_PATH_LENGTH);
 619   if (TempDevicePath == NULL) {
 620     return NULL;
 621   }
 622   TempDevicePath = CopyMem (TempDevicePath, DevicePathNode, NodeLength);
 623   //
 624   // Add and end device path node to convert Node to device path
 625   //
 626   NextNode = NextDevicePathNode (TempDevicePath);
 627   SetDevicePathEndNode (NextNode);
 628   //
 629   // Append device paths
 630   //
 631   NewDevicePath = AppendDevicePath (DevicePath, TempDevicePath);
 632
 633   FreePool (TempDevicePath);
 634
 635   return NewDevicePath;
 636 }