Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 45df901c authored by H. Peter Anvin's avatar H. Peter Anvin
Browse files

Merge tag 'efi-urgent' into x86/urgent 



 * More tweaking to the EFI variable anti-bricking algorithm. Quite a
   few users were reporting boot regressions in v3.9. This has now been
   fixed with a more accurate "minimum storage requirement to avoid
   bricking" value from Samsung (5K instead of 50%) and code to trigger
   garbage collection when we near our limit - Matthew Garrett.

Signed-off-by: default avatarH. Peter Anvin <hpa@linux.intel.com>
parents c8a22d19 f8b84043

arch/x86/boot/compressed/eboot.c

+0 −47
Original line number Diff line number Diff line
@@ -251,51 +251,6 @@ static void find_bits(unsigned long mask, u8 *pos, u8 *size) 
	*size = len;

}



static efi_status_t setup_efi_vars(struct boot_params *params)

{

	struct setup_data *data;

	struct efi_var_bootdata *efidata;

	u64 store_size, remaining_size, var_size;

	efi_status_t status;



	if (sys_table->runtime->hdr.revision < EFI_2_00_SYSTEM_TABLE_REVISION)

		return EFI_UNSUPPORTED;



	data = (struct setup_data *)(unsigned long)params->hdr.setup_data;



	while (data && data->next)

		data = (struct setup_data *)(unsigned long)data->next;



	status = efi_call_phys4((void *)sys_table->runtime->query_variable_info,

				EFI_VARIABLE_NON_VOLATILE |

				EFI_VARIABLE_BOOTSERVICE_ACCESS |

				EFI_VARIABLE_RUNTIME_ACCESS, &store_size,

				&remaining_size, &var_size);



	if (status != EFI_SUCCESS)

		return status;



	status = efi_call_phys3(sys_table->boottime->allocate_pool,

				EFI_LOADER_DATA, sizeof(*efidata), &efidata);



	if (status != EFI_SUCCESS)

		return status;



	efidata->data.type = SETUP_EFI_VARS;

	efidata->data.len = sizeof(struct efi_var_bootdata) -

		sizeof(struct setup_data);

	efidata->data.next = 0;

	efidata->store_size = store_size;

	efidata->remaining_size = remaining_size;

	efidata->max_var_size = var_size;



	if (data)

		data->next = (unsigned long)efidata;

	else

		params->hdr.setup_data = (unsigned long)efidata;



}



static efi_status_t setup_efi_pci(struct boot_params *params)

{

	efi_pci_io_protocol *pci;
@@ -1202,8 +1157,6 @@ struct boot_params *efi_main(void *handle, efi_system_table_t *_table, 


	setup_graphics(boot_params);



	setup_efi_vars(boot_params);



	setup_efi_pci(boot_params);



	status = efi_call_phys3(sys_table->boottime->allocate_pool,

arch/x86/include/asm/efi.h

+0 −7
Original line number Diff line number Diff line
@@ -102,13 +102,6 @@ extern void efi_call_phys_epilog(void); 
extern void efi_unmap_memmap(void);

extern void efi_memory_uc(u64 addr, unsigned long size);



struct efi_var_bootdata {

	struct setup_data data;

	u64 store_size;

	u64 remaining_size;

	u64 max_var_size;

};



#ifdef CONFIG_EFI



static inline bool efi_is_native(void)

arch/x86/include/uapi/asm/bootparam.h

+0 −1
Original line number Diff line number Diff line
@@ -6,7 +6,6 @@ 
#define SETUP_E820_EXT			1

#define SETUP_DTB			2

#define SETUP_PCI			3

#define SETUP_EFI_VARS			4



/* ram_size flags */

#define RAMDISK_IMAGE_START_MASK	0x07FF

arch/x86/platform/efi/efi.c

+65 −123
Original line number Diff line number Diff line
@@ -42,7 +42,6 @@ 
#include <linux/io.h>

#include <linux/reboot.h>

#include <linux/bcd.h>

#include <linux/ucs2_string.h>



#include <asm/setup.h>

#include <asm/efi.h>
@@ -54,12 +53,12 @@ 


#define EFI_DEBUG	1



/*

 * There's some additional metadata associated with each

 * variable. Intel's reference implementation is 60 bytes - bump that

 * to account for potential alignment constraints

 */

#define VAR_METADATA_SIZE 64

#define EFI_MIN_RESERVE 5120



#define EFI_DUMMY_GUID \

	EFI_GUID(0x4424ac57, 0xbe4b, 0x47dd, 0x9e, 0x97, 0xed, 0x50, 0xf0, 0x9f, 0x92, 0xa9)



static efi_char16_t efi_dummy_name[6] = { 'D', 'U', 'M', 'M', 'Y', 0 };



struct efi __read_mostly efi = {

	.mps        = EFI_INVALID_TABLE_ADDR,
@@ -79,13 +78,6 @@ struct efi_memory_map memmap; 
static struct efi efi_phys __initdata;

static efi_system_table_t efi_systab __initdata;



static u64 efi_var_store_size;

static u64 efi_var_remaining_size;

static u64 efi_var_max_var_size;

static u64 boot_used_size;

static u64 boot_var_size;

static u64 active_size;



unsigned long x86_efi_facility;



/*
@@ -188,53 +180,8 @@ static efi_status_t virt_efi_get_next_variable(unsigned long *name_size, 
					       efi_char16_t *name,

					       efi_guid_t *vendor)

{

	efi_status_t status;

	static bool finished = false;

	static u64 var_size;



	status = efi_call_virt3(get_next_variable,

	return efi_call_virt3(get_next_variable,

			      name_size, name, vendor);



	if (status == EFI_NOT_FOUND) {

		finished = true;

		if (var_size < boot_used_size) {

			boot_var_size = boot_used_size - var_size;

			active_size += boot_var_size;

		} else {

			printk(KERN_WARNING FW_BUG  "efi: Inconsistent initial sizes\n");

		}

	}



	if (boot_used_size && !finished) {

		unsigned long size = 0;

		u32 attr;

		efi_status_t s;

		void *tmp;



		s = virt_efi_get_variable(name, vendor, &attr, &size, NULL);



		if (s != EFI_BUFFER_TOO_SMALL || !size)

			return status;



		tmp = kmalloc(size, GFP_ATOMIC);



		if (!tmp)

			return status;



		s = virt_efi_get_variable(name, vendor, &attr, &size, tmp);



		if (s == EFI_SUCCESS && (attr & EFI_VARIABLE_NON_VOLATILE)) {

			var_size += size;

			var_size += ucs2_strsize(name, 1024);

			active_size += size;

			active_size += VAR_METADATA_SIZE;

			active_size += ucs2_strsize(name, 1024);

		}



		kfree(tmp);

	}



	return status;

}



static efi_status_t virt_efi_set_variable(efi_char16_t *name,
@@ -243,34 +190,9 @@ static efi_status_t virt_efi_set_variable(efi_char16_t *name, 
					  unsigned long data_size,

					  void *data)

{

	efi_status_t status;

	u32 orig_attr = 0;

	unsigned long orig_size = 0;



	status = virt_efi_get_variable(name, vendor, &orig_attr, &orig_size,

				       NULL);



	if (status != EFI_BUFFER_TOO_SMALL)

		orig_size = 0;



	status = efi_call_virt5(set_variable,

	return efi_call_virt5(set_variable,

			      name, vendor, attr,

			      data_size, data);



	if (status == EFI_SUCCESS) {

		if (orig_size) {

			active_size -= orig_size;

			active_size -= ucs2_strsize(name, 1024);

			active_size -= VAR_METADATA_SIZE;

		}

		if (data_size) {

			active_size += data_size;

			active_size += ucs2_strsize(name, 1024);

			active_size += VAR_METADATA_SIZE;

		}

	}



	return status;

}



static efi_status_t virt_efi_query_variable_info(u32 attr,
@@ -786,9 +708,6 @@ void __init efi_init(void) 
	char vendor[100] = "unknown";

	int i = 0;

	void *tmp;

	struct setup_data *data;

	struct efi_var_bootdata *efi_var_data;

	u64 pa_data;



#ifdef CONFIG_X86_32

	if (boot_params.efi_info.efi_systab_hi ||
@@ -806,22 +725,6 @@ void __init efi_init(void) 
	if (efi_systab_init(efi_phys.systab))

		return;



	pa_data = boot_params.hdr.setup_data;

	while (pa_data) {

		data = early_ioremap(pa_data, sizeof(*efi_var_data));

		if (data->type == SETUP_EFI_VARS) {

			efi_var_data = (struct efi_var_bootdata *)data;



			efi_var_store_size = efi_var_data->store_size;

			efi_var_remaining_size = efi_var_data->remaining_size;

			efi_var_max_var_size = efi_var_data->max_var_size;

		}

		pa_data = data->next;

		early_iounmap(data, sizeof(*efi_var_data));

	}



	boot_used_size = efi_var_store_size - efi_var_remaining_size;



	set_bit(EFI_SYSTEM_TABLES, &x86_efi_facility);



	/*
@@ -1085,6 +988,13 @@ void __init efi_enter_virtual_mode(void) 
		runtime_code_page_mkexec();



	kfree(new_memmap);



	/* clean DUMMY object */

	efi.set_variable(efi_dummy_name, &EFI_DUMMY_GUID,

			 EFI_VARIABLE_NON_VOLATILE |

			 EFI_VARIABLE_BOOTSERVICE_ACCESS |

			 EFI_VARIABLE_RUNTIME_ACCESS,

			 0, NULL);

}



/*
@@ -1136,33 +1046,65 @@ efi_status_t efi_query_variable_store(u32 attributes, unsigned long size) 
	efi_status_t status;

	u64 storage_size, remaining_size, max_size;



	if (!(attributes & EFI_VARIABLE_NON_VOLATILE))

		return 0;



	status = efi.query_variable_info(attributes, &storage_size,

					 &remaining_size, &max_size);

	if (status != EFI_SUCCESS)

		return status;



	if (!max_size && remaining_size > size)

		printk_once(KERN_ERR FW_BUG "Broken EFI implementation"

			    " is returning MaxVariableSize=0\n");

	/*

	 * Some firmware implementations refuse to boot if there's insufficient

	 * space in the variable store. We account for that by refusing the

	 * write if permitting it would reduce the available space to under

	 * 50%. However, some firmware won't reclaim variable space until

	 * after the used (not merely the actively used) space drops below

	 * a threshold. We can approximate that case with the value calculated

	 * above. If both the firmware and our calculations indicate that the

	 * available space would drop below 50%, refuse the write.

	 * 5KB. This figure was provided by Samsung, so should be safe.

	 */

	if ((remaining_size - size < EFI_MIN_RESERVE) &&

		!efi_no_storage_paranoia) {



	if (!storage_size || size > remaining_size ||

	    (max_size && size > max_size))

		return EFI_OUT_OF_RESOURCES;

		/*

		 * Triggering garbage collection may require that the firmware

		 * generate a real EFI_OUT_OF_RESOURCES error. We can force

		 * that by attempting to use more space than is available.

		 */

		unsigned long dummy_size = remaining_size + 1024;

		void *dummy = kmalloc(dummy_size, GFP_ATOMIC);



		status = efi.set_variable(efi_dummy_name, &EFI_DUMMY_GUID,

					  EFI_VARIABLE_NON_VOLATILE |

					  EFI_VARIABLE_BOOTSERVICE_ACCESS |

					  EFI_VARIABLE_RUNTIME_ACCESS,

					  dummy_size, dummy);



	if (!efi_no_storage_paranoia &&

	    ((active_size + size + VAR_METADATA_SIZE > storage_size / 2) &&

	     (remaining_size - size < storage_size / 2)))

		if (status == EFI_SUCCESS) {

			/*

			 * This should have failed, so if it didn't make sure

			 * that we delete it...

			 */

			efi.set_variable(efi_dummy_name, &EFI_DUMMY_GUID,

					 EFI_VARIABLE_NON_VOLATILE |

					 EFI_VARIABLE_BOOTSERVICE_ACCESS |

					 EFI_VARIABLE_RUNTIME_ACCESS,

					 0, dummy);

		}



		/*

		 * The runtime code may now have triggered a garbage collection

		 * run, so check the variable info again

		 */

		status = efi.query_variable_info(attributes, &storage_size,

						 &remaining_size, &max_size);



		if (status != EFI_SUCCESS)

			return status;



		/*

		 * There still isn't enough room, so return an error

		 */

		if (remaining_size - size < EFI_MIN_RESERVE)

			return EFI_OUT_OF_RESOURCES;

	}



	return EFI_SUCCESS;

}