/* ----------------------------------------------------------------------- *
*
* Copyright 2007-2008 H. Peter Anvin - All Rights Reserved
* Copyright 2012 Intel Corporation; author: H. Peter Anvin
* Chandramouli Narayanan
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, Inc., 53 Temple Place Ste 330,
* Boston MA 02111-1307, USA; either version 2 of the License, or
* (at your option) any later version; incorporated herein by reference.
*
* ----------------------------------------------------------------------- */
/*
* adv.c
*
* Core ADV I/O
* Code consolidated from libinstaller/adv*.c and core/adv.inc with the
* addition of EFI support
*
* Return 0 on success, -1 on error, and set errno.
*
*/
#define _GNU_SOURCE
#include <syslinux/config.h>
#include <string.h>
#include "adv.h"
unsigned char syslinux_adv[2 * ADV_SIZE];
static void cleanup_adv(unsigned char *advbuf)
{
int i;
uint32_t csum;
/* Make sure both copies agree, and update the checksum */
*(uint32_t *)advbuf = ADV_MAGIC1;
csum = ADV_MAGIC2;
for (i = 8; i < ADV_SIZE - 4; i += 4)
csum -= *(uint32_t *)(advbuf + i);
*(uint32_t *)(advbuf + 4) = csum;
*(uint32_t *)(advbuf + ADV_SIZE - 4) = ADV_MAGIC3;
memcpy(advbuf + ADV_SIZE, advbuf, ADV_SIZE);
}
void syslinux_reset_adv(unsigned char *advbuf)
{
/* Create an all-zero ADV */
memset(advbuf + 2 * 4, 0, ADV_LEN);
cleanup_adv(advbuf);
}
static int adv_consistent(const unsigned char *p)
{
int i;
uint32_t csum;
if (*(uint32_t *)p != ADV_MAGIC1 ||
*(uint32_t *)(p + ADV_SIZE - 4) != ADV_MAGIC3)
return 0;
csum = 0;
for (i = 4; i < ADV_SIZE - 4; i += 4)
csum += *(uint32_t *)(p + i);
return csum == ADV_MAGIC2;
}
/*
* Verify that an in-memory ADV is consistent, making the copies consistent.
* If neither copy is OK, return -1 and call syslinux_reset_adv().
*/
int syslinux_validate_adv(unsigned char *advbuf)
{
if (adv_consistent(advbuf + 0 * ADV_SIZE)) {
memcpy(advbuf + ADV_SIZE, advbuf, ADV_SIZE);
return 0;
} else if (adv_consistent(advbuf + 1 * ADV_SIZE)) {
memcpy(advbuf, advbuf + ADV_SIZE, ADV_SIZE);
return 0;
} else {
syslinux_reset_adv(advbuf);
return -1;
}
}
/*
* Read the ADV from an existing instance, or initialize if invalid.
* Returns -1 on fatal errors, 0 if ADV is okay, 1 if the ADV is
* invalid, and 2 if the file does not exist.
*/
/* make_filespec
* Take the ASCII pathname and filename and concatenate them
* into an allocated memory space as unicode file specification string.
* The path and cfg ASCII strings are assumed to be null-terminated.
* For EFI, the separation character in the path name is '\'
* and therefore it is assumed that the file spec uses '\' as separation char
*
* The function returns
* 0 if successful and fspec is a valid allocated CHAR16 pointer
* Caller is responsible to free up the allocated filespec string
* -1 otherwise
*
*/
static int make_filespec(CHAR16 **fspec, const char *path, const char *cfg)
{
CHAR16 *p;
int size, append;
/* allocate size for a CHAR16 string */
size = sizeof(CHAR16) * (strlena((CHAR8 *)path)+strlena((CHAR8 *)cfg)+2); /* including null */
*fspec = malloc(size);
if (!*fspec) return -1;
append = path[strlena((CHAR8 *)path) - 1] != '\\';
for (p = *fspec; *path; path++, p++)
*p = (CHAR16)*path;
/* append the separation character to the path if need be */
if (append) *p++ = (CHAR16)'\\';
for (; *cfg; cfg++, p++)
*p = (CHAR16)*cfg;
*p = (CHAR16)CHAR_NULL;
return 0;
}
/* TODO:
* set_attributes() and clear_attributes() are supported for VFAT only
*/
int read_adv(const char *path, const char *cfg)
{
CHAR16 *file;
EFI_FILE_HANDLE fd;
EFI_FILE_INFO st;
int err = 0;
int rv;
rv = make_filespec(&file, path, cfg);
if (rv < 0 || !file) {
efi_perror(L"read_adv");
return -1;
}
/* TBD: Not sure if EFI accepts the attribute read only
* even if an existing file is opened for read access
*/
fd = efi_open(file, EFI_FILE_MODE_READ);
if (!fd) {
if (efi_errno != EFI_NOT_FOUND) {
err = -1;
} else {
syslinux_reset_adv(syslinux_adv);
err = 2; /* Nonexistence is not a fatal error */
}
} else if (!efi_fstat(fd, &st)) {
err = -1;
} else if (st.FileSize < 2 * ADV_SIZE) {
/* Too small to be useful */
syslinux_reset_adv(syslinux_adv);
err = 0; /* Nothing to read... */
} else if (efi_xpread(fd, syslinux_adv, 2 * ADV_SIZE,
st.FileSize - 2 * ADV_SIZE) != 2 * ADV_SIZE) {
err = -1;
} else {
/* We got it... maybe? */
err = syslinux_validate_adv(syslinux_adv) ? 1 : 0;
}
if (err < 0)
efi_perror(file);
if (fd)
efi_close(fd);
free(file);
return err;
}
/* For EFI platform, initialize ADV by opening ldlinux.sys
* as configured and return the primary (adv0) and alternate (adv1)
* data into caller's buffer. File remains open for subsequent
* operations. This routine is to be called from comboot vector.
*/
void efi_adv_init(void)
{
union syslinux_derivative_info sdi;
get_derivative_info(&sdi);
if (sdi.c.filesystem == SYSLINUX_FS_SYSLINUX)
read_adv("", SYSLINUX_FILE);
else {
__syslinux_adv_ptr = &syslinux_adv[8]; /* skip head, csum */
__syslinux_adv_size = ADV_LEN;
syslinux_validate_adv(syslinux_adv);
}
}
/* For EFI platform, write 2 * ADV_SIZE data to the file opened
* at ADV initialization. (i.e ldlinux.sys).
*
* TODO:
* 1. Validate assumption: write back to file from __syslinux_adv_ptr
* 2. What if there errors?
* 3. Do we need to set the attributes of the sys file?
*
*/
int efi_adv_write(void)
{
char *name;
unsigned char advtmp[2 * ADV_SIZE];
unsigned char *advbuf = syslinux_adv;
int rv;
int err = 0;
EFI_FILE_HANDLE fd; /* handle to ldlinux.sys */
CHAR16 *file;
EFI_FILE_INFO st, xst;
union syslinux_derivative_info sdi;
get_derivative_info(&sdi);
if (sdi.c.filesystem != SYSLINUX_FS_SYSLINUX)
return -1;
name = SYSLINUX_FILE;
rv = make_filespec(&file, "", name);
if (rv < 0 || !file) {
efi_errno = EFI_OUT_OF_RESOURCES;
efi_perror(L"efi_adv_write:");
return -1;
}
fd = efi_open(file, EFI_FILE_MODE_READ);
if (fd == (EFI_FILE_HANDLE)NULL) {
err = -1;
efi_printerr(L"efi_adv_write: Unable to open file %s\n", file);
} else if (efi_fstat(fd, &st)) {
err = -1;
efi_printerr(L"efi_adv_write: Unable to get info for file %s\n", file);
} else if (st.FileSize < 2 * ADV_SIZE) {
/* Too small to be useful */
err = -2;
efi_printerr(L"efi_adv_write: File size too small to be useful for file %s\n", file);
} else if (efi_xpread(fd, advtmp, 2 * ADV_SIZE,
st.FileSize - 2 * ADV_SIZE) != 2 * ADV_SIZE) {
err = -1;
efi_printerr(L"efi_adv_write: Error reading ADV data from file %s\n", file);
} else {
cleanup_adv(advbuf);
err = syslinux_validate_adv(advbuf) ? -2 : 0;
if (!err) {
/* Got a good one, write our own ADV here */
efi_clear_attributes(fd);
/* Need to re-open read-write */
efi_close(fd);
/* There is no SYNC attribute with EFI open */
fd = efi_open(file, EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE);
if (fd == (EFI_FILE_HANDLE)NULL) {
err = -1;
} else if (efi_fstat(fd, &xst) || xst.FileSize != st.FileSize) {
efi_perror(L"efi_adv_write: file status error/mismatch");
err = -2;
}
/* Write our own version ... */
if (efi_xpwrite(fd, advbuf, 2 * ADV_SIZE,
st.FileSize - 2 * ADV_SIZE) != 2 * ADV_SIZE) {
err = -1;
efi_printerr(L"efi_adv_write: Error write ADV data to file %s\n", file);
}
if (!err) {
efi_sync(fd);
efi_set_attributes(fd);
}
}
}
if (err == -2)
efi_printerr(L"%s: cannot write auxilliary data (need --update)?\n",
file);
else if (err == -1)
efi_perror(L"efi_adv_write:");
if (fd)
efi_close(fd);
if (file)
free(file);
return err;
}