mirrors/u-boot
1
0
Fork 0
mirror of https://source.denx.de/u-boot/u-boot.git synced 2025-08-07 15:56:59 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

efi: Rename END to EFI_DP_END

Browse Source 
This exported symbol has a very generic name. Rename it to indicate that
it relates to EFI and device-paths.

Fix checkpatch warnings related to use of multiple assignments.

Signed-off-by: Simon Glass <sjg@chromium.org>
Suggested-by: Heinrich Schuchardt <heinrich.schuchardt@canonical.com>
Signed-off-by: Heinrich Schuchardt <heinrich.schuchardt@canonical.com>
This commit is contained in:
Simon Glass 2025-05-24 11:28:23 -06:00 committed by Heinrich Schuchardt
parent f139fbe64b
commit 162a6b3df3
7 changed files with 68 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
cmd/eficonfig.c
View File

@ -515,7 +515,7 @@ struct efi_device_path *eficonfig_create_device_path(struct efi_device_path *dp_
struct efi_device_path_file_path *fp; struct efi_device_path_file_path *fp;
fp_size = sizeof(struct efi_device_path) + u16_strsize(current_path); fp_size = sizeof(struct efi_device_path) + u16_strsize(current_path);
buf = calloc(1, fp_size + sizeof(END)); buf = calloc(1, fp_size + sizeof(EFI_DP_END));
if (!buf) if (!buf)
return NULL; return NULL;
@ -527,7 +527,7 @@ struct efi_device_path *eficonfig_create_device_path(struct efi_device_path *dp_
p = buf; p = buf;
p += fp_size; p += fp_size;
*((struct efi_device_path *)p) = END; *((struct efi_device_path *)p) = EFI_DP_END;
dp = efi_dp_shorten(dp_volume); dp = efi_dp_shorten(dp_volume);
if (!dp) if (!dp)

6
cmd/efidebug.c
View File

@ -813,7 +813,7 @@ static int efi_boot_add_uri(int argc, char *const argv[], u16 *var_name16,
lo->label = label; lo->label = label;
uridp_len = sizeof(struct efi_device_path) + strlen(argv[3]) + 1; uridp_len = sizeof(struct efi_device_path) + strlen(argv[3]) + 1;
uridp = efi_alloc(uridp_len + sizeof(END)); uridp = efi_alloc(uridp_len + sizeof(EFI_DP_END));
if (!uridp) { if (!uridp) {
log_err("Out of memory\n"); log_err("Out of memory\n");
return CMD_RET_FAILURE; return CMD_RET_FAILURE;
@ -823,10 +823,10 @@ static int efi_boot_add_uri(int argc, char *const argv[], u16 *var_name16,
uridp->dp.length = uridp_len; uridp->dp.length = uridp_len;
strcpy(uridp->uri, argv[3]); strcpy(uridp->uri, argv[3]);
pos = (char *)uridp + uridp_len; pos = (char *)uridp + uridp_len;
memcpy(pos, &END, sizeof(END)); memcpy(pos, &EFI_DP_END, sizeof(EFI_DP_END));
*file_path = &uridp->dp; *file_path = &uridp->dp;
*fp_size += uridp_len + sizeof(END); *fp_size += uridp_len + sizeof(EFI_DP_END);
return CMD_RET_SUCCESS; return CMD_RET_SUCCESS;
} }

27
include/efi_device_path.h
View File

@ -15,12 +15,12 @@ struct efi_load_option;
struct udevice; struct udevice;
/* /*
* END - Template end node for EFI device paths. * EFI_DP_END - Template end node for EFI device paths.
* *
* Represents the terminating node of an EFI device path. * Represents the terminating node of an EFI device path.
* It has a type of DEVICE_PATH_TYPE_END and sub_type DEVICE_PATH_SUB_TYPE_END * It has a type of DEVICE_PATH_TYPE_END and sub_type DEVICE_PATH_SUB_TYPE_END
*/ */
extern const struct efi_device_path END; extern const struct efi_device_path EFI_DP_END;
/** /**
* efi_dp_next() - Iterate to next block in device-path * efi_dp_next() - Iterate to next block in device-path
@ -85,11 +85,11 @@ efi_handle_t efi_dp_find_obj(struct efi_device_path *dp, const efi_guid_t *guid,
* efi_dp_last_node() - Determine the last device path node before the end node * efi_dp_last_node() - Determine the last device path node before the end node
* *
* Iterate through the device path to find the very last node before * Iterate through the device path to find the very last node before
* the terminating END node. * the terminating EFI_DP_END node.
* *
* @dp: Pointer to the device path. * @dp: Pointer to the device path.
* Return: Pointer to the last actual data node before the end node if it exists * Return: Pointer to the last actual data node before the end node if it exists
* otherwise NULL (e.g., if dp is NULL or only an END node). * otherwise NULL (e.g., if dp is NULL or only an EFI_DP_END node).
*/ */
const struct efi_device_path *efi_dp_last_node(const struct efi_device_path *dp); const struct efi_device_path *efi_dp_last_node(const struct efi_device_path *dp);
@ -101,8 +101,8 @@ const struct efi_device_path *efi_dp_last_node(const struct efi_device_path *dp)
* end node (if any) or the final device path. The end node is not included. * end node (if any) or the final device path. The end node is not included.
* *
* @dp: Pointer to the device path. * @dp: Pointer to the device path.
* Return: Size in bytes of the first instance, or 0 if dp is NULL or an END * Return: Size in bytes of the first instance, or 0 if dp is NULL or an
* node * EFI_DP_END node
*/ */
efi_uintn_t efi_dp_instance_size(const struct efi_device_path *dp); efi_uintn_t efi_dp_instance_size(const struct efi_device_path *dp);
@ -115,7 +115,7 @@ efi_uintn_t efi_dp_instance_size(const struct efi_device_path *dp);
* *
* @dp: Pointer to the device path. * @dp: Pointer to the device path.
* Return: Total size in bytes of all nodes in the device path (excluding the * Return: Total size in bytes of all nodes in the device path (excluding the
* final END node), or 0 if dp is NULL. * final EFI_DP_END node), or 0 if dp is NULL.
*/ */
efi_uintn_t efi_dp_size(const struct efi_device_path *dp); efi_uintn_t efi_dp_size(const struct efi_device_path *dp);
@ -139,7 +139,7 @@ struct efi_device_path *efi_dp_dup(const struct efi_device_path *dp);
* @dp2: Second device path * @dp2: Second device path
* @split_end_node: * @split_end_node:
* - 0 to concatenate (dp1 is assumed not to have an end node or it's ignored, * - 0 to concatenate (dp1 is assumed not to have an end node or it's ignored,
* dp2 is appended, then one END node) * dp2 is appended, then one EFI_DP_END node)
* - 1 to concatenate with end node added as separator (dp1, END_THIS_INSTANCE, * - 1 to concatenate with end node added as separator (dp1, END_THIS_INSTANCE,
* dp2, END_ENTIRE) * dp2, END_ENTIRE)
* *
@ -160,10 +160,11 @@ struct efi_device_path *efi_dp_concat(const struct efi_device_path *dp1,
* Create a new device path by appending a given node to an existing * Create a new device path by appending a given node to an existing
* device path. * device path.
* If the original device path @dp is NULL, a new path is created * If the original device path @dp is NULL, a new path is created
* with the given @node followed by an END node. * with the given @node followed by an EFI_DP_END node.
* If the @node is NULL and @dp is not NULL, the original path @dp is * If the @node is NULL and @dp is not NULL, the original path @dp is
* duplicated. * duplicated.
* If both @dp and @node are NULL, a path with only an END node is returned. * If both @dp and @node are NULL, a path with only an EFI_DP_END node is
* returned.
* The caller must free the returned path (e.g., using efi_free()). * The caller must free the returned path (e.g., using efi_free()).
* *
* @dp: Original device path (can be NULL). * @dp: Original device path (can be NULL).
@ -216,7 +217,7 @@ efi_dp_append_instance(const struct efi_device_path *dp,
* *
* Given a pointer to a pointer to a device path (@dp), this function extracts * Given a pointer to a pointer to a device path (@dp), this function extracts
* the first instance from the path. It allocates a new path for this extracted * the first instance from the path. It allocates a new path for this extracted
* instance (including its instance-specific END node). The input pointer * instance (including its instance-specific EFI_DP_END node). The input pointer
* (*@dp) is then updated to point to the start of the next instance in the * (*@dp) is then updated to point to the start of the next instance in the
* original path, or set to NULL if no more instances remain. * original path, or set to NULL if no more instances remain.
* The caller is responsible for freeing the returned instance path (e.g., * The caller is responsible for freeing the returned instance path (e.g.,
@ -226,7 +227,7 @@ efi_dp_append_instance(const struct efi_device_path *dp,
* On output, *@dp is updated to point to the start of the next instance, * On output, *@dp is updated to point to the start of the next instance,
* or NULL if no more instances. * or NULL if no more instances.
* @size: Optional pointer to an efi_uintn_t variable that will receive the size * @size: Optional pointer to an efi_uintn_t variable that will receive the size
* of the extracted instance path (including its END node). * of the extracted instance path (including its EFI_DP_END node).
* Return: Pointer to a newly allocated device path for the extracted instance, * Return: Pointer to a newly allocated device path for the extracted instance,
* or NULL if no instance could be extracted or an error occurred (e.g., * or NULL if no instance could be extracted or an error occurred (e.g.,
* allocation failure). * allocation failure).
@ -408,7 +409,7 @@ struct efi_device_path *search_gpt_dp_node(struct efi_device_path *device_path);
* *
* Set the device path to an IPv4 path as provided by efi_dp_from_ipv4 * Set the device path to an IPv4 path as provided by efi_dp_from_ipv4
* concatenated with a device path of subtype DEVICE_PATH_SUB_TYPE_MSG_URI, * concatenated with a device path of subtype DEVICE_PATH_SUB_TYPE_MSG_URI,
* and an END node. * and an EFI_DP_END node.
* *
* @server: URI of remote server * @server: URI of remote server
* @dev: net udevice * @dev: net udevice

3
lib/efi_loader/efi_bootmgr.c
View File

@ -856,7 +856,8 @@ efi_bootmgr_enumerate_boot_options(struct eficonfig_media_boot_option *opt,
lo.label = dev_name; lo.label = dev_name;
lo.attributes = LOAD_OPTION_ACTIVE; lo.attributes = LOAD_OPTION_ACTIVE;
lo.file_path = device_path; lo.file_path = device_path;
lo.file_path_length = efi_dp_size(device_path) + sizeof(END); lo.file_path_length = efi_dp_size(device_path) +
sizeof(EFI_DP_END);
/* /*
* Set the dedicated guid to optional_data, it is used to identify * Set the dedicated guid to optional_data, it is used to identify
* the boot option that automatically generated by the bootmenu. * the boot option that automatically generated by the bootmenu.

86
lib/efi_loader/efi_device_path.c
View File

@ -22,11 +22,11 @@
#include <asm-generic/unaligned.h> #include <asm-generic/unaligned.h>
#include <linux/compat.h> /* U16_MAX */ #include <linux/compat.h> /* U16_MAX */
/* template END node: */ /* template EFI_DP_END node: */
const struct efi_device_path END = { const struct efi_device_path EFI_DP_END = {
.type = DEVICE_PATH_TYPE_END, .type = DEVICE_PATH_TYPE_END,
.sub_type = DEVICE_PATH_SUB_TYPE_END, .sub_type = DEVICE_PATH_SUB_TYPE_END,
.length = sizeof(END), .length = sizeof(EFI_DP_END),
}; };
#if defined(CONFIG_MMC) #if defined(CONFIG_MMC)
@ -214,7 +214,7 @@ efi_uintn_t efi_dp_size(const struct efi_device_path *dp)
struct efi_device_path *efi_dp_dup(const struct efi_device_path *dp) struct efi_device_path *efi_dp_dup(const struct efi_device_path *dp)
{ {
struct efi_device_path *ndp; struct efi_device_path *ndp;
size_t sz = efi_dp_size(dp) + sizeof(END); size_t sz = efi_dp_size(dp) + sizeof(EFI_DP_END);
if (!dp) if (!dp)
return NULL; return NULL;
@ -237,7 +237,7 @@ efi_device_path *efi_dp_concat(const struct efi_device_path *dp1,
if (!dp1 && !dp2) { if (!dp1 && !dp2) {
/* return an end node */ /* return an end node */
ret = efi_dp_dup(&END); ret = efi_dp_dup(&EFI_DP_END);
} else if (!dp1) { } else if (!dp1) {
ret = efi_dp_dup(dp2); ret = efi_dp_dup(dp2);
} else if (!dp2) { } else if (!dp2) {
@ -254,9 +254,9 @@ efi_device_path *efi_dp_concat(const struct efi_device_path *dp1,
sz1 = split_end_node; sz1 = split_end_node;
if (split_end_node) if (split_end_node)
end_size = 2 * sizeof(END); end_size = 2 * sizeof(EFI_DP_END);
else else
end_size = sizeof(END); end_size = sizeof(EFI_DP_END);
p = efi_alloc(sz1 + sz2 + end_size); p = efi_alloc(sz1 + sz2 + end_size);
if (!p) if (!p)
return NULL; return NULL;
@ -265,14 +265,14 @@ efi_device_path *efi_dp_concat(const struct efi_device_path *dp1,
p += sz1; p += sz1;
if (split_end_node) { if (split_end_node) {
memcpy(p, &END, sizeof(END)); memcpy(p, &EFI_DP_END, sizeof(EFI_DP_END));
p += sizeof(END); p += sizeof(EFI_DP_END);
} }
/* the end node of the second device path has to be retained */ /* the end node of the second device path has to be retained */
memcpy(p, dp2, sz2); memcpy(p, dp2, sz2);
p += sz2; p += sz2;
memcpy(p, &END, sizeof(END)); memcpy(p, &EFI_DP_END, sizeof(EFI_DP_END));
} }
return ret; return ret;
@ -284,26 +284,26 @@ struct efi_device_path *efi_dp_append_node(const struct efi_device_path *dp,
struct efi_device_path *ret; struct efi_device_path *ret;
if (!node && !dp) { if (!node && !dp) {
ret = efi_dp_dup(&END); ret = efi_dp_dup(&EFI_DP_END);
} else if (!node) { } else if (!node) {
ret = efi_dp_dup(dp); ret = efi_dp_dup(dp);
} else if (!dp) { } else if (!dp) {
size_t sz = node->length; size_t sz = node->length;
void *p = efi_alloc(sz + sizeof(END)); void *p = efi_alloc(sz + sizeof(EFI_DP_END));
if (!p) if (!p)
return NULL; return NULL;
memcpy(p, node, sz); memcpy(p, node, sz);
memcpy(p + sz, &END, sizeof(END)); memcpy(p + sz, &EFI_DP_END, sizeof(EFI_DP_END));
ret = p; ret = p;
} else { } else {
/* both dp and node are non-null */ /* both dp and node are non-null */
size_t sz = efi_dp_size(dp); size_t sz = efi_dp_size(dp);
void *p = efi_alloc(sz + node->length + sizeof(END)); void *p = efi_alloc(sz + node->length + sizeof(EFI_DP_END));
if (!p) if (!p)
return NULL; return NULL;
memcpy(p, dp, sz); memcpy(p, dp, sz);
memcpy(p + sz, node, node->length); memcpy(p + sz, node, node->length);
memcpy(p + sz + node->length, &END, sizeof(END)); memcpy(p + sz + node->length, &EFI_DP_END, sizeof(EFI_DP_END));
ret = p; ret = p;
} }
@ -341,17 +341,17 @@ struct efi_device_path *efi_dp_append_instance(
return efi_dp_dup(dpi); return efi_dp_dup(dpi);
sz = efi_dp_size(dp); sz = efi_dp_size(dp);
szi = efi_dp_instance_size(dpi); szi = efi_dp_instance_size(dpi);
p = efi_alloc(sz + szi + 2 * sizeof(END)); p = efi_alloc(sz + szi + 2 * sizeof(EFI_DP_END));
if (!p) if (!p)
return NULL; return NULL;
ret = p; ret = p;
memcpy(p, dp, sz + sizeof(END)); memcpy(p, dp, sz + sizeof(EFI_DP_END));
p = (void *)p + sz; p = (void *)p + sz;
p->sub_type = DEVICE_PATH_SUB_TYPE_INSTANCE_END; p->sub_type = DEVICE_PATH_SUB_TYPE_INSTANCE_END;
p = (void *)p + sizeof(END); p = (void *)p + sizeof(EFI_DP_END);
memcpy(p, dpi, szi); memcpy(p, dpi, szi);
p = (void *)p + szi; p = (void *)p + szi;
memcpy(p, &END, sizeof(END)); memcpy(p, &EFI_DP_END, sizeof(EFI_DP_END));
return ret; return ret;
} }
@ -366,17 +366,17 @@ struct efi_device_path *efi_dp_get_next_instance(struct efi_device_path **dp,
if (!dp || !*dp) if (!dp || !*dp)
return NULL; return NULL;
sz = efi_dp_instance_size(*dp); sz = efi_dp_instance_size(*dp);
p = efi_alloc(sz + sizeof(END)); p = efi_alloc(sz + sizeof(EFI_DP_END));
if (!p) if (!p)
return NULL; return NULL;
memcpy(p, *dp, sz + sizeof(END)); memcpy(p, *dp, sz + sizeof(EFI_DP_END));
*dp = (void *)*dp + sz; *dp = (void *)*dp + sz;
if ((*dp)->sub_type == DEVICE_PATH_SUB_TYPE_INSTANCE_END) if ((*dp)->sub_type == DEVICE_PATH_SUB_TYPE_INSTANCE_END)
*dp = (void *)*dp + sizeof(END); *dp = (void *)*dp + sizeof(EFI_DP_END);
else else
*dp = NULL; *dp = NULL;
if (size) if (size)
*size = sz + sizeof(END); *size = sz + sizeof(EFI_DP_END);
return p; return p;
} }
@ -763,13 +763,13 @@ struct efi_device_path *efi_dp_from_part(struct blk_desc *desc, int part)
{ {
void *buf, *start; void *buf, *start;
start = buf = efi_alloc(dp_part_size(desc, part) + sizeof(END)); start = efi_alloc(dp_part_size(desc, part) + sizeof(EFI_DP_END));
if (!buf) if (!start)
return NULL; return NULL;
buf = dp_part_fill(buf, desc, part); buf = dp_part_fill(start, desc, part);
*((struct efi_device_path *)buf) = END; *((struct efi_device_path *)buf) = EFI_DP_END;
return start; return start;
} }
@ -836,7 +836,7 @@ struct efi_device_path *efi_dp_from_file(const struct efi_device_path *dp,
if (fpsize > U16_MAX) if (fpsize > U16_MAX)
return NULL; return NULL;
buf = efi_alloc(dpsize + fpsize + sizeof(END)); buf = efi_alloc(dpsize + fpsize + sizeof(EFI_DP_END));
if (!buf) if (!buf)
return NULL; return NULL;
@ -853,7 +853,7 @@ struct efi_device_path *efi_dp_from_file(const struct efi_device_path *dp,
pos += fpsize; pos += fpsize;
} }
memcpy(pos, &END, sizeof(END)); memcpy(pos, &EFI_DP_END, sizeof(EFI_DP_END));
return buf; return buf;
} }
@ -862,7 +862,7 @@ struct efi_device_path *efi_dp_from_uart(void)
{ {
void *buf, *pos; void *buf, *pos;
struct efi_device_path_uart *uart; struct efi_device_path_uart *uart;
size_t dpsize = dp_size(dm_root()) + sizeof(*uart) + sizeof(END); size_t dpsize = dp_size(dm_root()) + sizeof(*uart) + sizeof(EFI_DP_END);
buf = efi_alloc(dpsize); buf = efi_alloc(dpsize);
if (!buf) if (!buf)
@ -873,7 +873,7 @@ struct efi_device_path *efi_dp_from_uart(void)
uart->dp.sub_type = DEVICE_PATH_SUB_TYPE_MSG_UART; uart->dp.sub_type = DEVICE_PATH_SUB_TYPE_MSG_UART;
uart->dp.length = sizeof(*uart); uart->dp.length = sizeof(*uart);
pos += sizeof(*uart); pos += sizeof(*uart);
memcpy(pos, &END, sizeof(END)); memcpy(pos, &EFI_DP_END, sizeof(EFI_DP_END));
return buf; return buf;
} }
@ -887,13 +887,13 @@ struct efi_device_path __maybe_unused *efi_dp_from_eth(struct udevice *dev)
dpsize += dp_size(dev); dpsize += dp_size(dev);
start = buf = efi_alloc(dpsize + sizeof(END)); start = efi_alloc(dpsize + sizeof(EFI_DP_END));
if (!buf) if (!start)
return NULL; return NULL;
buf = dp_fill(buf, dev); buf = dp_fill(start, dev);
*((struct efi_device_path *)buf) = END; *((struct efi_device_path *)buf) = EFI_DP_END;
return start; return start;
} }
@ -903,7 +903,7 @@ struct efi_device_path __maybe_unused *efi_dp_from_eth(struct udevice *dev)
* *
* Set the device path to an ethernet device path as provided by * Set the device path to an ethernet device path as provided by
* efi_dp_from_eth() concatenated with a device path of subtype * efi_dp_from_eth() concatenated with a device path of subtype
* DEVICE_PATH_SUB_TYPE_MSG_IPV4, and an END node. * DEVICE_PATH_SUB_TYPE_MSG_IPV4, and an EFI_DP_END node.
* *
* @ip: IPv4 local address * @ip: IPv4 local address
* @mask: network mask * @mask: network mask
@ -934,7 +934,7 @@ static struct efi_device_path *efi_dp_from_ipv4(struct efi_ipv4_address *ip,
if (srv) if (srv)
memcpy(&dp.ipv4dp.remote_ip_address, srv, sizeof(*srv)); memcpy(&dp.ipv4dp.remote_ip_address, srv, sizeof(*srv));
pos = &dp.end; pos = &dp.end;
memcpy(pos, &END, sizeof(END)); memcpy(pos, &EFI_DP_END, sizeof(EFI_DP_END));
dp1 = efi_dp_from_eth(dev); dp1 = efi_dp_from_eth(dev);
if (!dp1) if (!dp1)
@ -979,7 +979,7 @@ struct efi_device_path *efi_dp_from_http(const char *server, struct udevice *dev
} }
uridp_len = sizeof(struct efi_device_path) + strlen(tmp) + 1; uridp_len = sizeof(struct efi_device_path) + strlen(tmp) + 1;
uridp = efi_alloc(uridp_len + sizeof(END)); uridp = efi_alloc(uridp_len + sizeof(EFI_DP_END));
if (!uridp) { if (!uridp) {
log_err("Out of memory\n"); log_err("Out of memory\n");
return NULL; return NULL;
@ -991,7 +991,7 @@ struct efi_device_path *efi_dp_from_http(const char *server, struct udevice *dev
memcpy(uridp->uri, tmp, strlen(tmp) + 1); memcpy(uridp->uri, tmp, strlen(tmp) + 1);
pos = (char *)uridp + uridp_len; pos = (char *)uridp + uridp_len;
memcpy(pos, &END, sizeof(END)); memcpy(pos, &EFI_DP_END, sizeof(EFI_DP_END));
dp2 = efi_dp_concat(dp1, (const struct efi_device_path *)uridp, 0); dp2 = efi_dp_concat(dp1, (const struct efi_device_path *)uridp, 0);
@ -1009,11 +1009,11 @@ struct efi_device_path *efi_dp_from_mem(uint32_t memory_type,
struct efi_device_path_memory *mdp; struct efi_device_path_memory *mdp;
void *buf, *start; void *buf, *start;
start = buf = efi_alloc(sizeof(*mdp) + sizeof(END)); start = efi_alloc(sizeof(*mdp) + sizeof(EFI_DP_END));
if (!buf) if (!start)
return NULL; return NULL;
mdp = buf; mdp = start;
mdp->dp.type = DEVICE_PATH_TYPE_HARDWARE_DEVICE; mdp->dp.type = DEVICE_PATH_TYPE_HARDWARE_DEVICE;
mdp->dp.sub_type = DEVICE_PATH_SUB_TYPE_MEMORY; mdp->dp.sub_type = DEVICE_PATH_SUB_TYPE_MEMORY;
mdp->dp.length = sizeof(*mdp); mdp->dp.length = sizeof(*mdp);
@ -1022,7 +1022,7 @@ struct efi_device_path *efi_dp_from_mem(uint32_t memory_type,
mdp->end_address = start_address + size; mdp->end_address = start_address + size;
buf = &mdp[1]; buf = &mdp[1];
*((struct efi_device_path *)buf) = END; *((struct efi_device_path *)buf) = EFI_DP_END;
return start; return start;
} }

2
lib/efi_loader/efi_device_path_utilities.c
View File

@ -32,7 +32,7 @@ static efi_uintn_t EFIAPI get_device_path_size(
efi_uintn_t sz = 0; efi_uintn_t sz = 0;
EFI_ENTRY("%pD", device_path); EFI_ENTRY("%pD", device_path);
/* size includes the END node: */ /* size includes the EFI_DP_END node: */
if (device_path) if (device_path)
sz = efi_dp_size(device_path) + sizeof(struct efi_device_path); sz = efi_dp_size(device_path) + sizeof(struct efi_device_path);
return EFI_EXIT(sz); return EFI_EXIT(sz);

6
lib/efi_loader/efi_helper.c
View File

@ -200,7 +200,7 @@ efi_status_t efi_load_option_dp_join(struct efi_device_path **dp,
efi_free_pool(tmp_dp); efi_free_pool(tmp_dp);
if (!*dp) if (!*dp)
return EFI_OUT_OF_RESOURCES; return EFI_OUT_OF_RESOURCES;
*dp_size += efi_dp_size(initrd_dp) + sizeof(END); *dp_size += efi_dp_size(initrd_dp) + sizeof(EFI_DP_END);
} }
if (fdt_dp) { if (fdt_dp) {
@ -210,10 +210,10 @@ efi_status_t efi_load_option_dp_join(struct efi_device_path **dp,
efi_free_pool(tmp_dp); efi_free_pool(tmp_dp);
if (!*dp) if (!*dp)
return EFI_OUT_OF_RESOURCES; return EFI_OUT_OF_RESOURCES;
*dp_size += efi_dp_size(fdt_dp) + sizeof(END); *dp_size += efi_dp_size(fdt_dp) + sizeof(EFI_DP_END);
} }
*dp_size += sizeof(END); *dp_size += sizeof(EFI_DP_END);
return EFI_SUCCESS; return EFI_SUCCESS;
} }