#include "efiboot.h"
-static int
-__attribute__((__nonnull__ (1,2,3)))
+static int NONNULL(1, 2, 3)
find_file(const char * const filepath, char **devicep, char **relpathp)
{
struct stat fsb = { 0, };
return ret;
}
-ssize_t
-__attribute__((__nonnull__ (3, 5)))
-__attribute__((__visibility__ ("default")))
+ssize_t NONNULL(3, 5) PUBLIC
efi_generate_file_device_path_from_esp(uint8_t *buf, ssize_t size,
const char *devpath, int partition,
const char *relpath,
return ret;
}
-ssize_t
-__attribute__((__nonnull__ (3)))
-__attribute__((__visibility__ ("default")))
+ssize_t NONNULL(3) PUBLIC
efi_generate_file_device_path(uint8_t *buf, ssize_t size,
const char * const filepath,
uint32_t options, ...)
return ret;
}
-static ssize_t
-__attribute__((__nonnull__ (3,4,5,6)))
+static ssize_t NONNULL(3, 4, 5, 6)
make_ipv4_path(uint8_t *buf, ssize_t size,
- const char * const local_addr __attribute__((unused)),
- const char * const remote_addr __attribute__((unused)),
- const char * const gateway_addr __attribute__((unused)),
- const char * const netmask __attribute__((unused)),
- uint16_t local_port __attribute__((unused)),
- uint16_t remote_port __attribute__((unused)),
- uint16_t protocol __attribute__((unused)),
- uint8_t addr_origin __attribute__((unused)))
+ const char * const local_addr UNUSED,
+ const char * const remote_addr UNUSED,
+ const char * const gateway_addr UNUSED,
+ const char * const netmask UNUSED,
+ uint16_t local_port UNUSED,
+ uint16_t remote_port UNUSED,
+ uint16_t protocol UNUSED,
+ uint8_t addr_origin UNUSED)
{
ssize_t ret;
return ret;
}
-ssize_t
-__attribute__((__nonnull__ (3,4,5,6,7)))
-__attribute__((__visibility__ ("default")))
+ssize_t NONNULL(3, 4, 5, 6, 7) PUBLIC
efi_generate_ipv4_device_path(uint8_t *buf, ssize_t size,
const char * const ifname,
const char * const local_addr,
*
************************************************************/
static int
-msdos_disk_get_extended_partition_info (int fd __attribute__((unused)),
- legacy_mbr *mbr __attribute__((unused)),
- uint32_t num __attribute__((unused)),
- uint64_t *start __attribute__((unused)),
- uint64_t *size __attribute__((unused)))
+msdos_disk_get_extended_partition_info (int fd UNUSED,
+ legacy_mbr *mbr UNUSED,
+ uint32_t num UNUSED,
+ uint64_t *start UNUSED,
+ uint64_t *size UNUSED)
{
/* Until I can handle these... */
//fprintf(stderr, "Extended partition info not supported.\n");
legacy_mbr *mbr;
void *mbr_sector;
size_t mbr_size;
- off_t offset __attribute__((unused));
+ off_t offset UNUSED;
int this_bytes_read = 0;
int gpt_invalid=0, mbr_invalid=0;
int rc=0;
return rc;
}
-ssize_t
-__attribute__((__visibility__ ("hidden")))
+ssize_t HIDDEN
_make_hd_dn(uint8_t *buf, ssize_t size, int fd, uint32_t partition,
uint32_t options)
{
extern ssize_t _make_hd_dn(uint8_t *buf, ssize_t size, int fd,
uint32_t partition, uint32_t options)
- __attribute__((__visibility__ ("hidden")));
+ HIDDEN;
#define make_hd_dn(buf, size, off, fd, partition, option) \
_make_hd_dn(((buf)+(off)), ((size)?((size)-(off)):0), (fd),\
(partition), (options))
static ssize_t
_format_acpi_adr(char *buf, size_t size,
- const char *dp_type __attribute__((__unused__)),
+ const char *dp_type UNUSED,
const_efidp dp)
{
ssize_t off = 0;
return off;
}
-ssize_t
-__attribute__((__visibility__ ("default")))
+ssize_t PUBLIC
efidp_make_acpi_hid(uint8_t *buf, ssize_t size, uint32_t hid, uint32_t uid)
{
efidp_acpi_hid *acpi_hid = (efidp_acpi_hid *)buf;
return sz;
}
-ssize_t
-__attribute__((__visibility__ ("default")))
-__attribute__((__nonnull__ (6,7,8)))
+ssize_t PUBLIC NONNULL(6, 7, 8)
efidp_make_acpi_hid_ex(uint8_t *buf, ssize_t size,
uint32_t hid, uint32_t uid, uint32_t cid,
char *hidstr, char *uidstr, char *cidstr)
return off;
}
-ssize_t
-__attribute__((__visibility__ ("default")))
+ssize_t PUBLIC
efidp_make_pci(uint8_t *buf, ssize_t size, uint8_t device, uint8_t function)
{
efidp_pci *pci = (efidp_pci *)buf;
return sz;
}
-ssize_t
-__attribute__((__visibility__ ("default")))
+ssize_t PUBLIC
efidp_make_edd10(uint8_t *buf, ssize_t size, uint32_t hardware_device)
{
efi_guid_t edd10_guid = EDD10_HARDWARE_VENDOR_PATH_GUID;
return off;
}
-ssize_t
-__attribute__((__visibility__ ("default")))
+ssize_t PUBLIC
efidp_make_file(uint8_t *buf, ssize_t size, char *filepath)
{
efidp_file *file = (efidp_file *)buf;
return sz;
}
-ssize_t
-__attribute__((__visibility__ ("default")))
+ssize_t PUBLIC
efidp_make_hd(uint8_t *buf, ssize_t size, uint32_t num, uint64_t part_start,
uint64_t part_size, uint8_t *signature, uint8_t format,
uint8_t signature_type)
static ssize_t
format_ip_addr_helper(char *buf, size_t size,
- const char *dp_type __attribute__((__unused__)),
+ const char *dp_type UNUSED,
int is_ipv6, const efi_ip_addr_t *addr)
{
ssize_t off = 0;
static ssize_t
format_uart(char *buf, size_t size,
- const char *dp_type __attribute__((__unused__)),
+ const char *dp_type UNUSED,
const_efidp dp)
{
uint32_t value;
static ssize_t
format_sas(char *buf, size_t size,
- const char *dp_type __attribute__((__unused__)),
+ const char *dp_type UNUSED,
const_efidp dp)
{
ssize_t off = 0;
static ssize_t
format_usb_class(char *buf, size_t size,
- const char *dp_type __attribute__((__unused__)),
+ const char *dp_type UNUSED,
const_efidp dp)
{
ssize_t off = 0;
efi_guid_t guid;
char label[40];
ssize_t (*formatter)(char *buf, size_t size,
- const char *dp_type __attribute__((__unused__)),
+ const char *dp_type UNUSED,
const_efidp dp);
} subtypes[] = {
{ .guid = EFIDP_PC_ANSI_GUID,
};
char *label = NULL;
ssize_t (*formatter)(char *buf, size_t size,
- const char *dp_type __attribute__((__unused__)),
+ const char *dp_type UNUSED,
const_efidp dp) = NULL;
for (int i = 0; !efi_guid_is_zero(&subtypes[i].guid); i++) {
return off;
}
-ssize_t
-__attribute__((__visibility__ ("default")))
+ssize_t PUBLIC
efidp_make_mac_addr(uint8_t *buf, ssize_t size, uint8_t if_type,
const uint8_t * const mac_addr, ssize_t mac_addr_size)
{
return sz;
}
-ssize_t
-__attribute__((__visibility__ ("default")))
+ssize_t PUBLIC
efidp_make_ipv4(uint8_t *buf, ssize_t size, uint32_t local, uint32_t remote,
uint32_t gateway, uint32_t netmask,
uint16_t local_port, uint16_t remote_port,
return sz;
}
-ssize_t
-__attribute__((__visibility__ ("default")))
+ssize_t PUBLIC
efidp_make_scsi(uint8_t *buf, ssize_t size, uint16_t target, uint16_t lun)
{
efidp_scsi *scsi = (efidp_scsi *)buf;
return sz;
}
-ssize_t
-__attribute__((__visibility__ ("default")))
+ssize_t PUBLIC
efidp_make_nvme(uint8_t *buf, ssize_t size, uint32_t namespace_id,
uint8_t *ieee_eui_64)
{
return sz;
}
-ssize_t
-__attribute__((__visibility__ ("default")))
+ssize_t PUBLIC
efidp_make_sata(uint8_t *buf, ssize_t size, uint16_t hba_port,
int16_t port_multiplier_port, uint16_t lun)
{
return sz;
}
-ssize_t
-__attribute__((__visibility__ ("default")))
+ssize_t PUBLIC
efidp_make_atapi(uint8_t *buf, ssize_t size, uint16_t primary,
uint16_t slave, uint16_t lun)
{
}
-ssize_t
-__attribute__((__visibility__ ("default")))
+ssize_t PUBLIC
efidp_make_sas(uint8_t *buf, ssize_t size, uint64_t sas_address)
{
efidp_sas *sas = (efidp_sas *)buf;
return sz;
}
-ssize_t
-__attribute__((__visibility__ ("default")))
+ssize_t PUBLIC
efidp_make_nvdimm(uint8_t *buf, ssize_t size, efi_guid_t *uuid)
{
efidp_nvdimm *nvdimm = (efidp_nvdimm *)buf;
return (void *)((uint8_t *)dp + sizeof (dp));
}
-int
-__attribute__((__visibility__ ("default")))
+int PUBLIC
efidp_set_node_data(const_efidp dn, void *buf, size_t bufsize)
{
if (dn->length < 4 || bufsize > (size_t)dn->length - 4) {
return 0;
}
-int
-__attribute__((__visibility__ ("default")))
+int PUBLIC
efidp_duplicate_path(const_efidp dp, efidp *out)
{
int rc;
return rc;
}
-int
-__attribute__((__visibility__ ("default")))
+int PUBLIC
efidp_append_path(const_efidp dp0, const_efidp dp1, efidp *out)
{
ssize_t lsz, rsz, newsz = 0;
return 0;
}
-int
-__attribute__((__visibility__ ("default")))
+int PUBLIC
efidp_append_node(const_efidp dp, const_efidp dn, efidp *out)
{
ssize_t lsz = 0, rsz = 0, newsz;
return 0;
}
-int
-__attribute__((__visibility__ ("default")))
+int PUBLIC
efidp_append_instance(const_efidp dp, const_efidp dpi, efidp *out)
{
ssize_t lsz, rsz;
}
-ssize_t
-__attribute__((__visibility__ ("default")))
+ssize_t PUBLIC
efidp_format_device_path(char *buf, size_t size, const_efidp dp, ssize_t limit)
{
ssize_t off = 0;
return off+1;
}
-ssize_t
-__attribute__((__visibility__ ("default")))
-efidp_parse_device_node(char *path __attribute__((unused)),
- efidp out __attribute__((unused)),
- size_t size __attribute__((unused)))
+ssize_t PUBLIC
+efidp_parse_device_node(char *path UNUSED, efidp out UNUSED,
+ size_t size UNUSED)
{
efi_error("not implented");
errno = -ENOSYS;
return -1;
}
-ssize_t
-__attribute__((__visibility__ ("default")))
-efidp_parse_device_path(char *path __attribute__((unused)),
- efidp out __attribute__((unused)),
- size_t size __attribute__((unused)))
+ssize_t PUBLIC
+efidp_parse_device_path(char *path UNUSED, efidp out UNUSED,
+ size_t size UNUSED)
{
efi_error("not implented");
errno = -ENOSYS;
return -1;
}
-ssize_t
-__attribute__((__visibility__ ("default")))
+ssize_t PUBLIC
efidp_make_vendor(uint8_t *buf, ssize_t size, uint8_t type, uint8_t subtype,
efi_guid_t vendor_guid, void *data, size_t data_size)
{
return sz;
}
-ssize_t
-__attribute__((__visibility__ ("default")))
+ssize_t PUBLIC
efidp_make_generic(uint8_t *buf, ssize_t size, uint8_t type, uint8_t subtype,
ssize_t total_size)
{
_rc; \
})
-static inline ssize_t
-__attribute__((__unused__))
+static inline ssize_t UNUSED
format_hex_helper(char *buf, size_t size, const char *dp_type, char *separator,
int stride, const void * const addr, const size_t len)
{
format_helper(format_hex_helper, buf, size, off, dp_type, sep, stride, \
addr, len)
-static inline ssize_t
-__attribute__((__unused__))
+static inline ssize_t UNUSED
format_vendor_helper(char *buf, size_t size, char *label, const_efidp dp)
{
ssize_t off = 0;
static error_table_entry *error_table;
static unsigned int current;
-int
-__attribute__((__visibility__ ("default")))
-__attribute__((__nonnull__ (2, 3, 4, 5, 6)))
+int PUBLIC NONNULL(2, 3, 4, 5, 6)
efi_error_get(unsigned int n,
char ** const filename,
char ** const function,
return 1;
}
-int
-__attribute__((__visibility__ ("default")))
-__attribute__((__nonnull__ (1, 2, 5)))
-__attribute__((__format__ (printf, 5, 6)))
+int PUBLIC NONNULL(1, 2, 5) PRINTF(5, 6)
efi_error_set(const char *filename,
const char *function,
int line,
return -1;
}
-void
-__attribute__((__visibility__ ("default")))
-__attribute__((destructor))
+void PUBLIC DESTRUCTOR
efi_error_clear(void)
{
if (error_table) {
* }
*/
-ssize_t
-__attribute__((__nonnull__ (1, 3)))
-__attribute__((__visibility__ ("default")))
+ssize_t NONNULL(1, 3) PUBLIC
efi_variable_import(uint8_t *data, size_t size, efi_variable_t **var_out)
{
efi_variable_t var;
return size;
}
-ssize_t
-__attribute__((__nonnull__ (1)))
-__attribute__((__visibility__ ("default")))
+ssize_t NONNULL(1) PUBLIC
efi_variable_export(efi_variable_t *var, uint8_t *data, size_t size)
{
size_t name_len = strlen(var->name);
return needed;
}
-efi_variable_t *
-#if 0 /* we get it from the decl instead of the defn here, because GCC gets
- * confused and thinks we're saying the /return type/ has visibility
- * and that makes no sense at all except in C++ where it's a class type.
- */
-__attribute__((__visibility__ ("default")))
-#endif
+efi_variable_t PUBLIC *
efi_variable_alloc(void)
{
efi_variable_t *var = calloc(1, sizeof (efi_variable_t));
return var;
}
-void
-__attribute__((__visibility__ ("default")))
+void PUBLIC
efi_variable_free(efi_variable_t *var, int free_data)
{
if (!var)
free(var);
}
-int
-__attribute__((__nonnull__ (1, 2)))
-__attribute__((__visibility__ ("default")))
+int NONNULL(1, 2) PUBLIC
efi_variable_set_name(efi_variable_t *var, char *name)
{
var->name = name;
return 0;
}
-char *
-__attribute__((__nonnull__ (1)))
-#if 0 /* we get it from the decl instead of the defn here, because GCC gets
- * confused and thinks we're saying the /return type/ has visibility
- * and that makes no sense at all except in C++ where it's a class type.
- */
-__attribute__((__visibility__ ("default")))
-#endif
+char PUBLIC NONNULL(1) *
efi_variable_get_name(efi_variable_t *var)
{
if (!var->name) {
return var->name;
}
-int
-__attribute__((__nonnull__ (1, 2)))
-__attribute__((__visibility__ ("default")))
+int NONNULL(1, 2) PUBLIC
efi_variable_set_guid(efi_variable_t *var, efi_guid_t *guid)
{
var->guid = guid;
return 0;
}
-int
-__attribute__((__nonnull__ (1, 2)))
-__attribute__((__visibility__ ("default")))
+int NONNULL(1, 2) PUBLIC
efi_variable_get_guid(efi_variable_t *var, efi_guid_t **guid)
{
if (!var->guid) {
return 0;
}
-int
-__attribute__((__nonnull__ (1, 2)))
-__attribute__((__visibility__ ("default")))
+int NONNULL(1, 2) PUBLIC
efi_variable_set_data(efi_variable_t *var, uint8_t *data, size_t size)
{
if (!size) {
return 0;
}
-ssize_t
-__attribute__((__nonnull__ (1, 2, 3)))
-__attribute__((__visibility__ ("default")))
+ssize_t NONNULL(1, 2, 3) PUBLIC
efi_variable_get_data(efi_variable_t *var, uint8_t **data, size_t *size)
{
if (var->data || !var->data_size) {
return 0;
}
-int
-__attribute__((__nonnull__ (1)))
-__attribute__((__visibility__ ("default")))
+int NONNULL(1) PUBLIC
efi_variable_set_attributes(efi_variable_t *var, uint64_t attrs)
{
var->attrs = attrs;
return 0;
}
-int
-__attribute__((__nonnull__ (1, 2)))
-__attribute__((__visibility__ ("default")))
+int NONNULL(1, 2) PUBLIC
efi_variable_get_attributes(efi_variable_t *var, uint64_t *attrs)
{
if (var->attrs == ATTRS_UNSET) {
return 0;
}
-int
-__attribute__((__nonnull__ (1)))
-__attribute__((__visibility__ ("default")))
+int NONNULL(1) PUBLIC
efi_variable_realize(efi_variable_t *var)
{
if (!var->name || !var->data || !var->data_size ||
static DIR *dir;
-static inline int
-__attribute__((unused))
+static inline int UNUSED
generic_get_next_variable_name(const char *path, efi_guid_t **guid, char **name)
{
static char ret_name[NAME_MAX+1];
return 1;
}
-static void __attribute__((destructor)) close_dir(void);
-static void
+static void DESTRUCTOR close_dir(void);
+static void DESTRUCTOR
close_dir(void)
{
if (dir != NULL) {
/* this is a simple read/delete/write implementation of "update". Good luck.
* -- pjones */
-static int
-__attribute__((__unused__))
-__attribute__((__flatten__))
+static int UNUSED FLATTEN
generic_append_variable(efi_guid_t guid, const char *name,
uint8_t *new_data, size_t new_data_size,
uint32_t new_attributes)
* non-zero on failure
*
************************************************************/
-int
-__attribute__((__nonnull__ (3, 4, 5, 6, 7)))
-__attribute__((__visibility__ ("hidden")))
+int NONNULL(3, 4, 5, 6, 7) HIDDEN
gpt_disk_get_partition_info(int fd, uint32_t num, uint64_t * start,
uint64_t * size, uint8_t *signature,
uint8_t * mbr_type, uint8_t * signature_type,
uint32_t sizeof_partition_entry;
uint32_t partition_entry_array_crc32;
uint8_t reserved2[GPT_BLOCK_SIZE - 92];
-} __attribute__ ((packed)) gpt_header;
+} PACKED gpt_header;
typedef struct _gpt_entry_attributes {
uint64_t required_to_function:1;
uint64_t reserved:47;
uint64_t type_guid_specific:16;
-} __attribute__ ((packed)) gpt_entry_attributes;
+} PACKED gpt_entry_attributes;
typedef struct _gpt_entry {
efi_guid_t partition_type_guid;
uint64_t ending_lba;
gpt_entry_attributes attributes;
uint16_t partition_name[72 / sizeof(uint16_t)];
-} __attribute__ ((packed)) gpt_entry;
+} PACKED gpt_entry;
/*
EFI firmware to define the start of the partition. */
uint32_t size_in_lba; /* Size of partition in LBA. Used by EFI firmware to determine
the size of the partition. */
-} __attribute__ ((packed)) partition_record;
+} PACKED partition_record;
/* Protected Master Boot Record & Legacy MBR share same structure */
uint16_t unknown;
partition_record partition[4];
uint16_t signature;
-} __attribute__ ((packed)) legacy_mbr;
+} PACKED legacy_mbr;
#define EFI_GPT_PRIMARY_PARTITION_TABLE_LBA 1
uint8_t *signature_type,
int ignore_pmbr_error,
int logical_sector_size)
- __attribute__((__nonnull__ (3, 4, 5, 6, 7)))
- __attribute__((__visibility__ ("hidden")));
+ NONNULL(3, 4, 5, 6, 7) HIDDEN;
#endif /* _EFIBOOT_GPT_H */
extern const efi_guid_t efi_guid_zero;
-int
-__attribute__((__nonnull__ (1, 2)))
-__attribute__((__visibility__ ("default")))
+int NONNULL(1, 2) PUBLIC
efi_guid_cmp(const efi_guid_t *a, const efi_guid_t *b)
{
return memcmp(a, b, sizeof (efi_guid_t));
}
-int
-__attribute__((__nonnull__ (1)))
-__attribute__((__visibility__ ("default")))
+int NONNULL(1) PUBLIC
efi_guid_is_zero(const efi_guid_t *guid)
{
return !efi_guid_cmp(guid,&efi_guid_zero);
int
efi_guid_is_empty(const efi_guid_t *guid)
-__attribute__((__nonnull__ (1)))
-__attribute__((__visibility__ ("default")))
-__attribute__ ((weak, alias ("efi_guid_is_zero")));
+ NONNULL(1) PUBLIC ALIAS(efi_guid_is_zero);
-int
-__attribute__((__nonnull__ (1, 2)))
-__attribute__((__visibility__ ("default")))
+int NONNULL(1, 2) PUBLIC
efi_str_to_guid(const char *s, efi_guid_t *guid)
{
int rc;
return rc;
}
-int
-__attribute__((__nonnull__ (1)))
-__attribute__((__visibility__ ("default")))
+int NONNULL(1) PUBLIC
efi_guid_to_str(const efi_guid_t *guid, char **sp)
{
char *ret = NULL;
return rc;
}
-extern struct guidname efi_well_known_guids
- __attribute__((__visibility__ ("default")));
-extern struct guidname efi_well_known_names
- __attribute__((__visibility__ ("default")));
-extern struct guidname efi_well_known_guids_end
- __attribute__((__visibility__ ("default")));
-extern struct guidname efi_well_known_names_end
- __attribute__((__visibility__ ("default")));
-
-static int
-__attribute__((__nonnull__ (1, 2)))
+extern struct guidname efi_well_known_guids PUBLIC;
+extern struct guidname efi_well_known_names PUBLIC;
+extern struct guidname efi_well_known_guids_end PUBLIC;
+extern struct guidname efi_well_known_names_end PUBLIC;
+
+static int NONNULL(1, 2)
cmpguidp(const void *p1, const void *p2)
{
struct guidname *gn1 = (struct guidname *)p1;
return memcmp(&gn1->guid, &gn2->guid, sizeof (gn1->guid));
}
-static int
-__attribute__((__nonnull__ (1, 2)))
+static int NONNULL(1, 2)
cmpnamep(const void *p1, const void *p2)
{
struct guidname *gn1 = (struct guidname *)p1;
return memcmp(gn1->name, gn2->name, sizeof (gn1->name));
}
-static int
-__attribute__((__nonnull__ (1, 2)))
+static int NONNULL(1, 2)
_get_common_guidname(const efi_guid_t *guid, struct guidname **result)
{
intptr_t end = (intptr_t)&efi_well_known_guids_end;
return 0;
}
-int
-__attribute__((__nonnull__ (1, 2)))
-__attribute__((__visibility__ ("default")))
+int NONNULL(1, 2) PUBLIC
efi_guid_to_name(efi_guid_t *guid, char **name)
{
struct guidname *result;
return rc;
}
-int
-__attribute__((__nonnull__ (1, 2)))
-__attribute__((__visibility__ ("default")))
+int NONNULL(1, 2) PUBLIC
efi_guid_to_symbol(efi_guid_t *guid, char **symbol)
{
struct guidname *result;
return -1;
}
-int
-__attribute__((__nonnull__ (1)))
-__attribute__((__visibility__ ("default")))
+int NONNULL(1) PUBLIC
efi_guid_to_id_guid(const efi_guid_t *guid, char **sp)
{
struct guidname *result = NULL;
return rc;
}
-int
-__attribute__((__nonnull__ (1, 2)))
-__attribute__((__visibility__ ("default")))
+int NONNULL(1, 2) PUBLIC
efi_symbol_to_guid(const char *symbol, efi_guid_t *guid)
{
void *dlh = dlopen(NULL, RTLD_LAZY);
return 0;
}
-int
-__attribute__((__nonnull__ (1, 2)))
-__attribute__((__visibility__ ("default")))
+int NONNULL(1, 2) PUBLIC
efi_name_to_guid(const char *name, efi_guid_t *guid)
{
intptr_t end = (intptr_t)&efi_well_known_names_end;
int
efi_id_guid_to_guid(const char *name, efi_guid_t *guid)
- __attribute__((__nonnull__ (1, 2)))
- __attribute__((__visibility__ ("default")))
- __attribute__ ((weak, alias ("efi_name_to_guid")));
+ NONNULL(1, 2) PUBLIC ALIAS(efi_name_to_guid);
return 0;
}
-static inline int
-__attribute__((unused))
+static inline int UNUSED
text_to_guid(const char *text, efi_guid_t *guid)
{
/* these variables represent the length of the /string/ they hold,
struct efi_var_operations *ops = NULL;
-int
-__attribute__((__nonnull__ (2, 3)))
-__attribute__((__visibility__ ("default")))
+int NONNULL(2, 3) PUBLIC
_efi_set_variable(efi_guid_t guid, const char *name, uint8_t *data,
size_t data_size, uint32_t attributes)
{
efi_error("ops->set_variable() failed");
return rc;
}
-__asm__(".symver _efi_set_variable,_efi_set_variable@libefivar.so.0");
+VERSION(_efi_set_variable, _efi_set_variable@libefivar.so.0);
-int
-__attribute__((__nonnull__ (2, 3)))
-__attribute__((__visibility__ ("default")))
+int NONNULL(2, 3) PUBLIC
_efi_set_variable_variadic(efi_guid_t guid, const char *name, uint8_t *data,
size_t data_size, uint32_t attributes, ...)
{
efi_error("ops->set_variable() failed");
return rc;
}
-__asm__(".symver _efi_set_variable_variadic,efi_set_variable@libefivar.so.0");
+VERSION(_efi_set_variable_variadic, efi_set_variable@libefivar.so.0);
-int
-__attribute__((__nonnull__ (2, 3)))
-__attribute__((__visibility__ ("default")))
+int NONNULL(2, 3) PUBLIC
_efi_set_variable_mode(efi_guid_t guid, const char *name, uint8_t *data,
size_t data_size, uint32_t attributes, mode_t mode)
{
efi_error_clear();
return rc;
}
-__asm__(".symver _efi_set_variable_mode,efi_set_variable@@LIBEFIVAR_0.24");
+VERSION(_efi_set_variable_mode,efi_set_variable@@LIBEFIVAR_0.24);
-int
-__attribute__((__nonnull__ (2, 3)))
-__attribute__((__visibility__ ("default")))
+int NONNULL(2, 3) PUBLIC
efi_set_variable(efi_guid_t guid, const char *name, uint8_t *data,
size_t data_size, uint32_t attributes, mode_t mode)
- __attribute((weak, alias ("_efi_set_variable_mode")));
+ ALIAS(_efi_set_variable_mode);
-int
-__attribute__((__nonnull__ (2, 3)))
-__attribute__((__visibility__ ("default")))
+int NONNULL(2, 3) PUBLIC
efi_append_variable(efi_guid_t guid, const char *name, uint8_t *data,
size_t data_size, uint32_t attributes)
{
return rc;
}
-int
-__attribute__((__nonnull__ (2)))
-__attribute__((__visibility__ ("default")))
+int NONNULL(2) PUBLIC
efi_del_variable(efi_guid_t guid, const char *name)
{
int rc;
return rc;
}
-int
-__attribute__((__nonnull__ (2, 3, 4, 5)))
-__attribute__((__visibility__ ("default")))
+int NONNULL(2, 3, 4, 5) PUBLIC
efi_get_variable(efi_guid_t guid, const char *name, uint8_t **data,
size_t *data_size, uint32_t *attributes)
{
return rc;
}
-int
-__attribute__((__nonnull__ (2, 3)))
-__attribute__((__visibility__ ("default")))
+int NONNULL(2, 3) PUBLIC
efi_get_variable_attributes(efi_guid_t guid, const char *name,
uint32_t *attributes)
{
return rc;
}
-int
-__attribute__((__nonnull__ (2)))
-__attribute__((__visibility__ ("default")))
+int NONNULL(2) PUBLIC
efi_get_variable_exists(efi_guid_t guid, const char *name)
{
uint32_t unused_attributes = 0;
return efi_get_variable_attributes(guid, name, &unused_attributes);
}
-int
-__attribute__((__nonnull__ (2, 3)))
-__attribute__((__visibility__ ("default")))
+int NONNULL(2, 3) PUBLIC
efi_get_variable_size(efi_guid_t guid, const char *name, size_t *size)
{
int rc;
return rc;
}
-int
-__attribute__((__nonnull__ (1, 2)))
-__attribute__((__visibility__ ("default")))
+int NONNULL(1, 2) PUBLIC
efi_get_next_variable_name(efi_guid_t **guid, char **name)
{
int rc;
return rc;
}
-int
-__attribute__((__nonnull__ (2)))
-__attribute__((__visibility__ ("default")))
+int NONNULL(2) PUBLIC
efi_chmod_variable(efi_guid_t guid, const char *name, mode_t mode)
{
int rc;
return rc;
}
-int
-__attribute__((__visibility__ ("default")))
+int PUBLIC
efi_variables_supported(void)
{
if (ops == &default_ops)
return 1;
}
-static void libefivar_init(void) __attribute__((constructor));
+static void libefivar_init(void) CONSTRUCTOR;
static void
libefivar_init(void)
#include "efiboot.h"
-int
-__attribute__((__visibility__ ("hidden")))
+int HIDDEN
set_disk_and_part_name(struct disk_info *info)
{
char *linkbuf;
return 0;
}
-int
-__attribute__((__visibility__ ("hidden")))
+int HIDDEN
get_partition_number(const char *devpath)
{
struct stat statbuf = { 0, };
return ret;
}
-int
-__attribute__((__visibility__ ("hidden")))
+int HIDDEN
find_parent_devpath(const char * const child, char **parent)
{
int ret;
*/
static ssize_t
sysfs_parse_pmem(uint8_t *buf, ssize_t size, ssize_t *off,
- const char *pbuf, ssize_t psize __attribute__((__unused__)),
- ssize_t *poff __attribute__((__unused__)),
- struct disk_info *info)
+ const char *pbuf, ssize_t psize UNUSED,
+ ssize_t *poff UNUSED, struct disk_info *info)
{
uint8_t *filebuf = NULL;
int rc;
return off;
}
-int
-__attribute__((__visibility__ ("hidden")))
+int HIDDEN
make_blockdev_path(uint8_t *buf, ssize_t size, struct disk_info *info)
{
char *linkbuf = NULL;
return off;
}
-int
-__attribute__((__visibility__ ("hidden")))
+int HIDDEN
eb_disk_info_from_fd(int fd, struct disk_info *info)
{
struct stat buf;
return off;
}
-ssize_t
-__attribute__((__visibility__ ("hidden")))
+ssize_t HIDDEN
make_mac_path(uint8_t *buf, ssize_t size, const char * const ifname)
{
struct ifreq ifr;
extern int eb_nvme_ns_id(int fd, uint32_t *ns_id);
extern int get_partition_number(const char *devpath)
- __attribute__((__visibility__ ("hidden")));
+ HIDDEN;
extern int find_parent_devpath(const char * const child, char **parent)
- __attribute__((__visibility__ ("hidden")));
+ HIDDEN;
extern ssize_t make_mac_path(uint8_t *buf, ssize_t size,
const char * const ifname)
- __attribute__((__visibility__ ("hidden")));
+ HIDDEN;
#endif /* _EFIBOOT_LINUX_H */
uint16_t description[];
// uint8_t file_path_list[];
// uint8_t optional_data[];
-}
-__attribute__((packed))
-efi_load_option;
+} PACKED efi_load_option;
-ssize_t
-__attribute__((__nonnull__ (6)))
-__attribute__((__visibility__ ("default")))
+ssize_t NONNULL(6) PUBLIC
efi_loadopt_create(uint8_t *buf, ssize_t size, uint32_t attributes,
efidp dp, ssize_t dp_size, unsigned char *description,
uint8_t *optional_data, size_t optional_data_size)
return sz;
}
-ssize_t
-__attribute__((__nonnull__ (1)))
-__attribute__((__visibility__ ("default")))
+ssize_t NONNULL(1) PUBLIC
efi_loadopt_optional_data_size(efi_load_option *opt, size_t size)
{
ssize_t sz;
return ret;
}
-int
-__attribute__((__nonnull__ (1)))
-__attribute__((__visibility__ ("default")))
+int NONNULL(1) PUBLIC
efi_loadopt_is_valid(efi_load_option *opt, size_t size)
{
ssize_t rc;
return (rc >= 0);
}
-uint32_t
-__attribute__((__nonnull__ (1)))
-__attribute__((__visibility__ ("default")))
+uint32_t NONNULL(1) PUBLIC
efi_loadopt_attrs(efi_load_option *opt)
{
return opt->attributes;
}
-void
-__attribute__((__nonnull__ (1)))
-__attribute__((__visibility__ ("default")))
+void NONNULL(1) PUBLIC
efi_loadopt_attr_set(efi_load_option *opt, uint16_t attr)
{
opt->attributes |= attr;
}
-void
-__attribute__((__nonnull__ (1)))
-__attribute__((__visibility__ ("default")))
+void NONNULL(1) PUBLIC
efi_loadopt_attr_clear(efi_load_option *opt, uint16_t attr)
{
opt->attributes &= ~attr;
}
-uint16_t
-__attribute__((__nonnull__ (1)))
-__attribute__((__visibility__ ("default")))
+uint16_t NONNULL(1) PUBLIC
/* limit here is the /whole/ load option */
efi_loadopt_pathlen(efi_load_option *opt, ssize_t limit)
{
return len;
}
-efidp
-__attribute__((__nonnull__ (1)))
-__attribute__((__visibility__ ("default")))
+efidp NONNULL(1) PUBLIC
/* limit here is the /whole/ load option */
efi_loadopt_path(efi_load_option *opt, ssize_t limit)
{
return dp;
}
-int
-__attribute__((__nonnull__ (1,3)))
-__attribute__((__visibility__ ("default")))
+int NONNULL(1,3) PUBLIC
efi_loadopt_optional_data(efi_load_option *opt, size_t opt_size,
unsigned char **datap, size_t *len)
{
return 0;
}
-ssize_t
-__attribute__((__nonnull__ (3)))
-__attribute__((__visibility__ ("default")))
+ssize_t NONNULL(3) PUBLIC
efi_loadopt_args_from_file(uint8_t *buf, ssize_t size, char *filename)
{
int rc;
return ret;
}
-ssize_t
-__attribute__((__nonnull__ (3)))
-__attribute__((__visibility__ ("default")))
+ssize_t NONNULL(3) PUBLIC
efi_loadopt_args_as_utf8(uint8_t *buf, ssize_t size, uint8_t *utf8)
{
ssize_t req;
return req;
}
-ssize_t
-__attribute__((__nonnull__ (3)))
-__attribute__((__visibility__ ("default")))
+ssize_t NONNULL(3) PUBLIC
efi_loadopt_args_as_ucs2(uint16_t *buf, ssize_t size, uint8_t *utf8)
{
ssize_t req;
static unsigned char *last_desc;
-static void
-__attribute__((destructor))
+static void DESTRUCTOR
teardown(void)
{
if (last_desc)
last_desc = NULL;
}
-__attribute__((__nonnull__ (1)))
-__attribute__((__visibility__ ("default")))
-const unsigned char *
+const unsigned char NONNULL(1) PUBLIC *
efi_loadopt_desc(efi_load_option *opt, ssize_t limit)
{
if (last_desc) {
#define ev_bits(val, mask, shift) \
(((val) & ((mask) << (shift))) >> (shift))
-static inline size_t
-__attribute__((__unused__))
+static inline size_t UNUSED
ucs2len(const uint16_t * const s, ssize_t limit)
{
ssize_t i;
return i;
}
-static inline size_t
-__attribute__((__unused__))
+static inline size_t UNUSED
ucs2size(const uint16_t * const s, ssize_t limit)
{
size_t rc = ucs2len(s, limit);
return rc;
}
-static inline size_t
-__attribute__((__unused__))
-__attribute__((__nonnull__ (1)))
+static inline size_t UNUSED NONNULL(1)
utf8len(uint8_t *s, ssize_t limit)
{
ssize_t i, j;
return j;
}
-static inline size_t
-__attribute__((__unused__))
-__attribute__((__nonnull__ (1)))
+static inline size_t UNUSED NONNULL(1)
utf8size(uint8_t *s, ssize_t limit)
{
size_t ret = utf8len(s,limit);
return ret;
}
-static inline unsigned char *
-__attribute__((__unused__))
+static inline unsigned char * UNUSED
ucs2_to_utf8(const uint16_t * const chars, ssize_t limit)
{
ssize_t i, j;
return (unsigned char *)strdup((char *)ret);
}
-static inline ssize_t
-__attribute__((__unused__))
-__attribute__((__nonnull__ (4)))
+static inline ssize_t UNUSED NONNULL(4)
utf8_to_ucs2(uint16_t *ucs2, ssize_t size, int terminate, uint8_t *utf8)
{
ssize_t req;
#include <tgmath.h>
#include <unistd.h>
+#define UNUSED __attribute__((__unused__))
+#define HIDDEN __attribute__((__visibility__ ("hidden")))
+#define PUBLIC __attribute__((__visibility__ ("default")))
+#define DESTRUCTOR __attribute__((destructor))
+#define CONSTRUCTOR __attribute__((constructor))
+#define ALIAS(x) __attribute__((weak, alias (#x)))
+#define NONNULL(...) __attribute__((__nonnull__(__VA_ARGS__)))
+#define PRINTF(...) __attribute__((__format__(printf, __VA_ARGS__)))
+#define FLATTEN __attribute__((__flatten__))
+#define PACKED __attribute__((__packed__))
+#define VERSION(sym, ver) __asm__(".symver " # sym "," # ver)
+
/*
* I'm not actually sure when these appear, but they're present in the
* version in front of me.
})
#endif
-
-static inline int
-__attribute__((unused))
+static inline int UNUSED
read_file(int fd, uint8_t **buf, size_t *bufsize)
{
uint8_t *p;
return 0;
}
-static inline uint64_t
-__attribute__((unused))
+static inline uint64_t UNUSED
lcm(uint64_t x, uint64_t y)
{
uint64_t m = x, n = y, o;
* Returns:
* sector size, or 512.
************************************************************/
-static inline int
-__attribute__((unused))
+static inline int UNUSED
get_sector_size(int filedes)
{
int rc, sector_size = 512;
_rc; \
})
-static inline void
-__attribute__((unused))
+static inline void UNUSED
swizzle_guid_to_uuid(efi_guid_t *guid)
{
uint32_t *u32;
uint8_t Data[1024];
uint32_t Status;
uint32_t Attributes;
-} __attribute__((packed)) efi_kernel_variable_32_t;
+} PACKED efi_kernel_variable_32_t;
typedef struct efi_kernel_variable_64_t {
uint16_t VariableName[1024/sizeof(uint16_t)];
uint8_t Data[1024];
uint64_t Status;
uint32_t Attributes;
-} __attribute__((packed)) efi_kernel_variable_64_t;
+} PACKED efi_kernel_variable_64_t;
static ssize_t
get_file_data_size(int dfd, char *name)