cleanup: always use BS and RT, not gBS and gRT

This just makes one less thing we have to make sure is the same between
the test harnesses and the runtime code.

Signed-off-by: Peter Jones <pjones@redhat.com>

13 files changed, 183 insertions, 184 deletions

diff --git a/MokManager.c b/MokManager.c
index cd1492f8..4b6ee146 100644
--- a/MokManager.c
+++ b/MokManager.c
@@ -735,7 +735,7 @@ done:
 
 static INTN reset_system()
 {
-	gRT->ResetSystem(EfiResetWarm, EFI_SUCCESS, 0, NULL);
+	RT->ResetSystem(EfiResetWarm, EFI_SUCCESS, 0, NULL);
 	console_notify(L"Failed to reboot\n");
 	return -1;
 }
@@ -883,10 +883,10 @@ static EFI_STATUS write_db(CHAR16 * db_name, void *MokNew, UINTN MokNewSize)
 	CopyMem(new_data, old_data, old_size);
 	CopyMem(new_data + old_size, MokNew, MokNewSize);
 
-	efi_status = gRT->SetVariable(db_name, &SHIM_LOCK_GUID,
-				      EFI_VARIABLE_NON_VOLATILE |
-				      EFI_VARIABLE_BOOTSERVICE_ACCESS,
-				      new_size, new_data);
+	efi_status = RT->SetVariable(db_name, &SHIM_LOCK_GUID,
+				     EFI_VARIABLE_NON_VOLATILE |
+				     EFI_VARIABLE_BOOTSERVICE_ACCESS,
+				     new_size, new_data);
 out:
 	if (old_size > 0) {
 		FreePool(old_data);
@@ -918,8 +918,8 @@ static EFI_STATUS store_keys(void *MokNew, UINTN MokNewSize, int authenticate,
 	}
 
 	if (authenticate) {
-		efi_status = gRT->GetVariable(auth_name, &SHIM_LOCK_GUID,
-					      &attributes, &auth_size, auth);
+		efi_status = RT->GetVariable(auth_name, &SHIM_LOCK_GUID,
+					     &attributes, &auth_size, auth);
 		if (EFI_ERROR(efi_status) ||
 		    (auth_size != SHA256_DIGEST_SIZE &&
 		     auth_size != PASSWORD_CRYPT_SIZE)) {
@@ -945,10 +945,10 @@ static EFI_STATUS store_keys(void *MokNew, UINTN MokNewSize, int authenticate,
 
 	if (!MokNewSize) {
 		/* Delete MOK */
-		efi_status = gRT->SetVariable(db_name, &SHIM_LOCK_GUID,
-					      EFI_VARIABLE_NON_VOLATILE |
-					      EFI_VARIABLE_BOOTSERVICE_ACCESS,
-					      0, NULL);
+		efi_status = RT->SetVariable(db_name, &SHIM_LOCK_GUID,
+					     EFI_VARIABLE_NON_VOLATILE |
+					     EFI_VARIABLE_BOOTSERVICE_ACCESS,
+					     0, NULL);
 	} else {
 		/* Write new MOK */
 		efi_status = write_db(db_name, MokNew, MokNewSize);
@@ -1064,10 +1064,10 @@ static EFI_STATUS write_back_mok_list(MokListNode * list, INTN key_num,
 	}
 	if (DataSize == 0) {
 		dprint(L"DataSize = 0; deleting variable %s\n", db_name);
-		efi_status = gRT->SetVariable(db_name, &SHIM_LOCK_GUID,
-					      EFI_VARIABLE_NON_VOLATILE |
-					      EFI_VARIABLE_BOOTSERVICE_ACCESS,
-					      DataSize, Data);
+		efi_status = RT->SetVariable(db_name, &SHIM_LOCK_GUID,
+					     EFI_VARIABLE_NON_VOLATILE |
+					     EFI_VARIABLE_BOOTSERVICE_ACCESS,
+					     DataSize, Data);
 		dprint(L"efi_status:%llu\n", efi_status);
 		return EFI_SUCCESS;
 	}
@@ -1109,10 +1109,10 @@ static EFI_STATUS write_back_mok_list(MokListNode * list, INTN key_num,
 		ptr = (uint8_t *) ptr + CertList->SignatureListSize;
 	}
 
-	efi_status = gRT->SetVariable(db_name, &SHIM_LOCK_GUID,
-				      EFI_VARIABLE_NON_VOLATILE |
-				      EFI_VARIABLE_BOOTSERVICE_ACCESS,
-				      DataSize, Data);
+	efi_status = RT->SetVariable(db_name, &SHIM_LOCK_GUID,
+				     EFI_VARIABLE_NON_VOLATILE |
+				     EFI_VARIABLE_BOOTSERVICE_ACCESS,
+				     DataSize, Data);
 	if (Data)
 		FreePool(Data);
 
@@ -1262,8 +1262,8 @@ static EFI_STATUS delete_keys(void *MokDel, UINTN MokDelSize, BOOLEAN MokX)
 		auth_name = L"MokDelAuth";
 	}
 
-	efi_status = gRT->GetVariable(auth_name, &SHIM_LOCK_GUID, &attributes,
-				      &auth_size, auth);
+	efi_status = RT->GetVariable(auth_name, &SHIM_LOCK_GUID, &attributes,
+				     &auth_size, auth);
 	if (EFI_ERROR(efi_status) ||
 	    (auth_size != SHA256_DIGEST_SIZE
 	     && auth_size != PASSWORD_CRYPT_SIZE)) {
@@ -1305,9 +1305,9 @@ static EFI_STATUS delete_keys(void *MokDel, UINTN MokDelSize, BOOLEAN MokX)
 			err_strs[1] = L"Erase all keys in MokList!";
 		}
 		console_alertbox(err_strs);
-		gRT->SetVariable(db_name, &SHIM_LOCK_GUID,
-				 EFI_VARIABLE_NON_VOLATILE |
-				 EFI_VARIABLE_BOOTSERVICE_ACCESS, 0, NULL);
+		RT->SetVariable(db_name, &SHIM_LOCK_GUID,
+				EFI_VARIABLE_NON_VOLATILE |
+				EFI_VARIABLE_BOOTSERVICE_ACCESS, 0, NULL);
 		efi_status = EFI_ACCESS_DENIED;
 		goto error;
 	}
@@ -1327,9 +1327,9 @@ static EFI_STATUS delete_keys(void *MokDel, UINTN MokDelSize, BOOLEAN MokX)
 			err_strs[1] = L"Reset MokList!";
 		}
 		console_alertbox(err_strs);
-		gRT->SetVariable(db_name, &SHIM_LOCK_GUID,
-				 EFI_VARIABLE_NON_VOLATILE |
-				 EFI_VARIABLE_BOOTSERVICE_ACCESS, 0, NULL);
+		RT->SetVariable(db_name, &SHIM_LOCK_GUID,
+				EFI_VARIABLE_NON_VOLATILE |
+				EFI_VARIABLE_BOOTSERVICE_ACCESS, 0, NULL);
 		efi_status = EFI_ABORTED;
 		goto error;
 	}
@@ -1541,19 +1541,19 @@ static EFI_STATUS mok_sb_prompt(void *MokSB, UINTN MokSBSize)
 	}
 
 	if (var->MokSBState == 0) {
-		efi_status = gRT->SetVariable(L"MokSBState", &SHIM_LOCK_GUID,
-					      EFI_VARIABLE_NON_VOLATILE |
-					      EFI_VARIABLE_BOOTSERVICE_ACCESS,
-					      1, &sbval);
+		efi_status = RT->SetVariable(L"MokSBState", &SHIM_LOCK_GUID,
+					     EFI_VARIABLE_NON_VOLATILE |
+					     EFI_VARIABLE_BOOTSERVICE_ACCESS,
+					     1, &sbval);
 		if (EFI_ERROR(efi_status)) {
 			console_notify(L"Failed to set Secure Boot state");
 			return efi_status;
 		}
 	} else {
-		efi_status = gRT->SetVariable(L"MokSBState", &SHIM_LOCK_GUID,
-					      EFI_VARIABLE_NON_VOLATILE |
-					      EFI_VARIABLE_BOOTSERVICE_ACCESS,
-					      0, NULL);
+		efi_status = RT->SetVariable(L"MokSBState", &SHIM_LOCK_GUID,
+					     EFI_VARIABLE_NON_VOLATILE |
+					     EFI_VARIABLE_BOOTSERVICE_ACCESS,
+					     0, NULL);
 		if (EFI_ERROR(efi_status)) {
 			console_notify(L"Failed to delete Secure Boot state");
 			return efi_status;
@@ -1656,19 +1656,19 @@ static EFI_STATUS mok_db_prompt(void *MokDB, UINTN MokDBSize)
 	}
 
 	if (var->MokDBState == 0) {
-		efi_status = gRT->SetVariable(L"MokDBState", &SHIM_LOCK_GUID,
-					      EFI_VARIABLE_NON_VOLATILE |
-					      EFI_VARIABLE_BOOTSERVICE_ACCESS,
-					      1, &dbval);
+		efi_status = RT->SetVariable(L"MokDBState", &SHIM_LOCK_GUID,
+					     EFI_VARIABLE_NON_VOLATILE |
+					     EFI_VARIABLE_BOOTSERVICE_ACCESS,
+					     1, &dbval);
 		if (EFI_ERROR(efi_status)) {
 			console_notify(L"Failed to set DB state");
 			return efi_status;
 		}
 	} else {
-		efi_status = gRT->SetVariable(L"MokDBState", &SHIM_LOCK_GUID,
-					      EFI_VARIABLE_NON_VOLATILE |
-					      EFI_VARIABLE_BOOTSERVICE_ACCESS,
-					      0, NULL);
+		efi_status = RT->SetVariable(L"MokDBState", &SHIM_LOCK_GUID,
+					     EFI_VARIABLE_NON_VOLATILE |
+					     EFI_VARIABLE_BOOTSERVICE_ACCESS,
+					     0, NULL);
 		if (EFI_ERROR(efi_status)) {
 			console_notify(L"Failed to delete DB state");
 			return efi_status;
@@ -1707,9 +1707,9 @@ static EFI_STATUS mok_pw_prompt(void *MokPW, UINTN MokPWSize)
 		if (console_yes_no(clear_p) == 0)
 			return EFI_ABORTED;
 
-		gRT->SetVariable(L"MokPWStore", &SHIM_LOCK_GUID,
-				 EFI_VARIABLE_NON_VOLATILE |
-				 EFI_VARIABLE_BOOTSERVICE_ACCESS, 0, NULL);
+		RT->SetVariable(L"MokPWStore", &SHIM_LOCK_GUID,
+				EFI_VARIABLE_NON_VOLATILE |
+				EFI_VARIABLE_BOOTSERVICE_ACCESS, 0, NULL);
 		goto mokpw_done;
 	}
 
@@ -1729,10 +1729,10 @@ static EFI_STATUS mok_pw_prompt(void *MokPW, UINTN MokPWSize)
 	if (console_yes_no(set_p) == 0)
 		return EFI_ABORTED;
 
-	efi_status = gRT->SetVariable(L"MokPWStore", &SHIM_LOCK_GUID,
-				      EFI_VARIABLE_NON_VOLATILE |
-				      EFI_VARIABLE_BOOTSERVICE_ACCESS,
-				      MokPWSize, MokPW);
+	efi_status = RT->SetVariable(L"MokPWStore", &SHIM_LOCK_GUID,
+				     EFI_VARIABLE_NON_VOLATILE |
+				     EFI_VARIABLE_BOOTSERVICE_ACCESS,
+				     MokPWSize, MokPW);
 	if (EFI_ERROR(efi_status)) {
 		console_notify(L"Failed to set MOK password");
 		return efi_status;
@@ -1994,8 +1994,8 @@ static BOOLEAN verify_pw(BOOLEAN * protected)
 
 	*protected = FALSE;
 
-	efi_status = gRT->GetVariable(L"MokPWStore", &SHIM_LOCK_GUID, &attributes,
-				      &size, pwhash);
+	efi_status = RT->GetVariable(L"MokPWStore", &SHIM_LOCK_GUID, &attributes,
+				     &size, pwhash);
 	/*
 	 * If anything can attack the password it could just set it to a
 	 * known value, so there's no safety advantage in failing to validate
@@ -2122,29 +2122,29 @@ static EFI_STATUS enter_mok_menu(EFI_HANDLE image_handle UNUSED,
 		UINT32 MokXAuth = 0;
 		UINT32 MokXDelAuth = 0;
 
-		efi_status = gRT->GetVariable(L"MokAuth", &SHIM_LOCK_GUID,
-					      &attributes, &auth_size, auth);
+		efi_status = RT->GetVariable(L"MokAuth", &SHIM_LOCK_GUID,
+					     &attributes, &auth_size, auth);
 		if (!EFI_ERROR(efi_status) &&
 		    (auth_size == SHA256_DIGEST_SIZE ||
 		     auth_size == PASSWORD_CRYPT_SIZE))
 			MokAuth = 1;
 
-		efi_status = gRT->GetVariable(L"MokDelAuth", &SHIM_LOCK_GUID,
-					      &attributes, &auth_size, auth);
+		efi_status = RT->GetVariable(L"MokDelAuth", &SHIM_LOCK_GUID,
+					     &attributes, &auth_size, auth);
 		if (!EFI_ERROR(efi_status) &&
 		    (auth_size == SHA256_DIGEST_SIZE ||
 		     auth_size == PASSWORD_CRYPT_SIZE))
 			MokDelAuth = 1;
 
-		efi_status = gRT->GetVariable(L"MokXAuth", &SHIM_LOCK_GUID,
-					      &attributes, &auth_size, auth);
+		efi_status = RT->GetVariable(L"MokXAuth", &SHIM_LOCK_GUID,
+					     &attributes, &auth_size, auth);
 		if (!EFI_ERROR(efi_status) &&
 		    (auth_size == SHA256_DIGEST_SIZE ||
 		     auth_size == PASSWORD_CRYPT_SIZE))
 			MokXAuth = 1;
 
-		efi_status = gRT->GetVariable(L"MokXDelAuth", &SHIM_LOCK_GUID,
-					      &attributes, &auth_size, auth);
+		efi_status = RT->GetVariable(L"MokXDelAuth", &SHIM_LOCK_GUID,
+					     &attributes, &auth_size, auth);
 		if (!EFI_ERROR(efi_status) &&
 		    (auth_size == SHA256_DIGEST_SIZE ||
 		     auth_size == PASSWORD_CRYPT_SIZE))
@@ -2496,7 +2496,7 @@ static EFI_STATUS setup_rand(void)
 	UINT64 seed;
 	BOOLEAN status;
 
-	efi_status = gRT->GetTime(&time, NULL);
+	efi_status = RT->GetTime(&time, NULL);
 	if (EFI_ERROR(efi_status))
 		return efi_status;
 
diff --git a/fallback.c b/fallback.c
index 302eeac1..ce907099 100644
--- a/fallback.c
+++ b/fallback.c
@@ -252,7 +252,7 @@ add_boot_option(EFI_DEVICE_PATH *hddp, EFI_DEVICE_PATH *fulldp,
 				first_new_option_size = StrLen(arguments) * sizeof (CHAR16);
 			}
 
-			efi_status = gRT->SetVariable(varname, &GV_GUID,
+			efi_status = RT->SetVariable(varname, &GV_GUID,
 						EFI_VARIABLE_NON_VOLATILE |
 						EFI_VARIABLE_BOOTSERVICE_ACCESS |
 						EFI_VARIABLE_RUNTIME_ACCESS,
@@ -431,8 +431,8 @@ find_boot_option(EFI_DEVICE_PATH *dp, EFI_DEVICE_PATH *fulldp,
 
 	while (1) {
 		UINTN varname_size = buffer_size;
-		efi_status = gRT->GetNextVariableName(&varname_size, varname,
-						      &vendor_guid);
+		efi_status = RT->GetNextVariableName(&varname_size, varname,
+						     &vendor_guid);
 		if (EFI_ERROR(efi_status)) {
 			if (efi_status == EFI_BUFFER_TOO_SMALL) {
 				VerbosePrint(L"Buffer too small for next variable name, re-allocating it to be %d bytes and retrying\n",
@@ -464,8 +464,8 @@ find_boot_option(EFI_DEVICE_PATH *dp, EFI_DEVICE_PATH *fulldp,
 			continue;
 
 		UINTN candidate_size = max_candidate_size;
-		efi_status = gRT->GetVariable(varname, &GV_GUID, NULL,
-					      &candidate_size, candidate);
+		efi_status = RT->GetVariable(varname, &GV_GUID, NULL,
+					     &candidate_size, candidate);
 		if (EFI_ERROR(efi_status))
 			continue;
 
@@ -543,15 +543,15 @@ update_boot_order(void)
 	for (j = 0 ; j < size / sizeof (CHAR16); j++)
 		VerbosePrintUnprefixed(L"%04x ", newbootorder[j]);
 	VerbosePrintUnprefixed(L"\n");
-	efi_status = gRT->GetVariable(L"BootOrder", &GV_GUID, NULL, &len, NULL);
+	efi_status = RT->GetVariable(L"BootOrder", &GV_GUID, NULL, &len, NULL);
 	if (efi_status == EFI_BUFFER_TOO_SMALL)
 		LibDeleteVariable(L"BootOrder", &GV_GUID);
 
-	efi_status = gRT->SetVariable(L"BootOrder", &GV_GUID,
-				      EFI_VARIABLE_NON_VOLATILE |
-				      EFI_VARIABLE_BOOTSERVICE_ACCESS |
-				      EFI_VARIABLE_RUNTIME_ACCESS,
-				      size, newbootorder);
+	efi_status = RT->SetVariable(L"BootOrder", &GV_GUID,
+				     EFI_VARIABLE_NON_VOLATILE |
+				     EFI_VARIABLE_BOOTSERVICE_ACCESS |
+				     EFI_VARIABLE_RUNTIME_ACCESS,
+				     size, newbootorder);
 	FreePool(newbootorder);
 	return efi_status;
 }
@@ -862,8 +862,8 @@ find_boot_options(EFI_HANDLE device)
 	EFI_STATUS efi_status;
 	EFI_FILE_IO_INTERFACE *fio = NULL;
 
-	efi_status = gBS->HandleProtocol(device, &FileSystemProtocol,
-					 (void **) &fio);
+	efi_status = BS->HandleProtocol(device, &FileSystemProtocol,
+					(void **) &fio);
 	if (EFI_ERROR(efi_status)) {
 		console_print(L"Couldn't find file system: %r\n", efi_status);
 		return efi_status;
@@ -990,8 +990,8 @@ try_start_first_option(EFI_HANDLE parent_image_handle)
 		return EFI_SUCCESS;
 	}
 
-	efi_status = gBS->LoadImage(0, parent_image_handle, first_new_option,
-				    NULL, 0, &image_handle);
+	efi_status = BS->LoadImage(0, parent_image_handle, first_new_option,
+				   NULL, 0, &image_handle);
 	if (EFI_ERROR(efi_status)) {
 		CHAR16 *dps = DevicePathToStr(first_new_option);
 		UINTN s = DevicePathSize(first_new_option);
@@ -1011,14 +1011,14 @@ try_start_first_option(EFI_HANDLE parent_image_handle)
 	}
 
 	EFI_LOADED_IMAGE *image;
-	efi_status = gBS->HandleProtocol(image_handle, &LoadedImageProtocol,
-					 (void *) &image);
+	efi_status = BS->HandleProtocol(image_handle, &LoadedImageProtocol,
+					(void *) &image);
 	if (!EFI_ERROR(efi_status)) {
 		image->LoadOptions = first_new_option_args;
 		image->LoadOptionsSize = first_new_option_size;
 	}
 
-	efi_status = gBS->StartImage(image_handle, NULL, NULL);
+	efi_status = BS->StartImage(image_handle, NULL, NULL);
 	if (EFI_ERROR(efi_status)) {
 		console_print(L"StartImage failed: %r\n", efi_status);
 		msleep(500000000);
@@ -1033,8 +1033,8 @@ get_fallback_no_reboot(void)
 	UINT32 no_reboot;
 	UINTN size = sizeof(UINT32);
 
-	efi_status = gRT->GetVariable(NO_REBOOT, &SHIM_LOCK_GUID,
-				      NULL, &size, &no_reboot);
+	efi_status = RT->GetVariable(NO_REBOOT, &SHIM_LOCK_GUID,
+				     NULL, &size, &no_reboot);
 	if (!EFI_ERROR(efi_status)) {
 		return no_reboot;
 	}
@@ -1047,11 +1047,11 @@ set_fallback_no_reboot(void)
 {
 	EFI_STATUS efi_status;
 	UINT32 no_reboot = 1;
-	efi_status = gRT->SetVariable(NO_REBOOT, &SHIM_LOCK_GUID,
-				      EFI_VARIABLE_NON_VOLATILE
-				      | EFI_VARIABLE_BOOTSERVICE_ACCESS
-				      | EFI_VARIABLE_RUNTIME_ACCESS,
-				      sizeof(UINT32), &no_reboot);
+	efi_status = RT->SetVariable(NO_REBOOT, &SHIM_LOCK_GUID,
+				     EFI_VARIABLE_NON_VOLATILE |
+				     EFI_VARIABLE_BOOTSERVICE_ACCESS |
+				     EFI_VARIABLE_RUNTIME_ACCESS,
+				     sizeof(UINT32), &no_reboot);
 	return efi_status;
 }
 
@@ -1129,8 +1129,8 @@ efi_main(EFI_HANDLE image, EFI_SYSTEM_TABLE *systab)
 	 */
 	debug_hook();
 
-	efi_status = gBS->HandleProtocol(image, &LoadedImageProtocol,
-					 (void *) &this_image);
+	efi_status = BS->HandleProtocol(image, &LoadedImageProtocol,
+					(void *) &this_image);
 	if (EFI_ERROR(efi_status)) {
 		console_print(L"Error: could not find loaded image: %r\n",
 			      efi_status);
@@ -1191,7 +1191,7 @@ reset:
 		msleep(fallback_verbose_wait);
 	}
 
-	gRT->ResetSystem(EfiResetCold, EFI_SUCCESS, 0, NULL);
+	RT->ResetSystem(EfiResetCold, EFI_SUCCESS, 0, NULL);
 
 	return EFI_SUCCESS;
 }
diff --git a/httpboot.c b/httpboot.c
index 3340a7f9..dfa493bf 100644
--- a/httpboot.c
+++ b/httpboot.c
@@ -232,9 +232,9 @@ get_nic_handle (EFI_MAC_ADDRESS *mac)
 
 	/* Get the list of handles that support the HTTP service binding
 	   protocol */
-	efi_status = gBS->LocateHandleBuffer(ByProtocol,
-					     &EFI_HTTP_BINDING_GUID,
-					     NULL, &NoHandles, &buffer);
+	efi_status = BS->LocateHandleBuffer(ByProtocol,
+					    &EFI_HTTP_BINDING_GUID,
+					    NULL, &NoHandles, &buffer);
 	if (EFI_ERROR(efi_status))
 		return NULL;
 
@@ -306,8 +306,8 @@ set_ip6(EFI_HANDLE *nic, IPv6_DEVICE_PATH *ip6node)
 	EFI_IPv6_ADDRESS gateway;
 	EFI_STATUS efi_status;
 
-	efi_status = gBS->HandleProtocol(nic, &EFI_IP6_CONFIG_GUID,
-					 (VOID **)&ip6cfg);
+	efi_status = BS->HandleProtocol(nic, &EFI_IP6_CONFIG_GUID,
+					(VOID **)&ip6cfg);
 	if (EFI_ERROR(efi_status))
 		return efi_status;
 
@@ -367,8 +367,8 @@ set_ip4(EFI_HANDLE *nic, IPv4_DEVICE_PATH *ip4node)
 	EFI_IPv4_ADDRESS gateway;
 	EFI_STATUS efi_status;
 
-	efi_status = gBS->HandleProtocol(nic, &EFI_IP4_CONFIG2_GUID,
-					 (VOID **)&ip4cfg2);
+	efi_status = BS->HandleProtocol(nic, &EFI_IP4_CONFIG2_GUID,
+					(VOID **)&ip4cfg2);
 	if (EFI_ERROR(efi_status))
 		return efi_status;
 
@@ -470,9 +470,9 @@ send_http_request (EFI_HTTP_PROTOCOL *http, CHAR8 *hostname, CHAR8 *uri)
 	tx_token.Message = &tx_message;
 	tx_token.Event = NULL;
 	request_done = FALSE;
-	efi_status = gBS->CreateEvent(EVT_NOTIFY_SIGNAL, TPL_NOTIFY,
-				      httpnotify, &request_done,
-				      &tx_token.Event);
+	efi_status = BS->CreateEvent(EVT_NOTIFY_SIGNAL, TPL_NOTIFY,
+				     httpnotify, &request_done,
+				     &tx_token.Event);
 	if (EFI_ERROR(efi_status)) {
 		perror(L"Failed to Create Event for HTTP request: %r\n",
 		       efi_status);
@@ -496,7 +496,7 @@ send_http_request (EFI_HTTP_PROTOCOL *http, CHAR8 *hostname, CHAR8 *uri)
 	}
 
 error:
-	event_status = gBS->CloseEvent(tx_token.Event);
+	event_status = BS->CloseEvent(tx_token.Event);
 	if (EFI_ERROR(event_status)) {
 		perror(L"Failed to close Event for HTTP request: %r\n",
 		       event_status);
@@ -534,9 +534,9 @@ receive_http_response(EFI_HTTP_PROTOCOL *http, VOID **buffer, UINT64 *buf_size)
 	rx_token.Message = &rx_message;
 	rx_token.Event = NULL;
 	response_done = FALSE;
-	efi_status = gBS->CreateEvent(EVT_NOTIFY_SIGNAL, TPL_NOTIFY,
-				      httpnotify, &response_done,
-				      &rx_token.Event);
+	efi_status = BS->CreateEvent(EVT_NOTIFY_SIGNAL, TPL_NOTIFY,
+				     httpnotify, &response_done,
+				     &rx_token.Event);
 	if (EFI_ERROR(efi_status)) {
 		perror(L"Failed to Create Event for HTTP response: %r\n",
 		       efi_status);
@@ -632,7 +632,7 @@ receive_http_response(EFI_HTTP_PROTOCOL *http, VOID **buffer, UINT64 *buf_size)
 	}
 
 error:
-	event_status = gBS->CloseEvent(rx_token.Event);
+	event_status = BS->CloseEvent(rx_token.Event);
 	if (EFI_ERROR(event_status)) {
 		perror(L"Failed to close Event for HTTP response: %r\n",
 		       event_status);
@@ -660,9 +660,9 @@ http_fetch (EFI_HANDLE image, EFI_HANDLE device,
 	*buf_size = 0;
 
 	/* Open HTTP Service Binding Protocol */
-	efi_status = gBS->OpenProtocol(device, &EFI_HTTP_BINDING_GUID,
-				       (VOID **) &service, image, NULL,
-				       EFI_OPEN_PROTOCOL_GET_PROTOCOL);
+	efi_status = BS->OpenProtocol(device, &EFI_HTTP_BINDING_GUID,
+				      (VOID **) &service, image, NULL,
+				      EFI_OPEN_PROTOCOL_GET_PROTOCOL);
 	if (EFI_ERROR(efi_status))
 		return efi_status;
 
@@ -676,8 +676,8 @@ http_fetch (EFI_HANDLE image, EFI_HANDLE device,
 	}
 
 	/* Get the http protocol */
-	efi_status = gBS->HandleProtocol(http_handle, &EFI_HTTP_PROTOCOL_GUID,
-					 (VOID **) &http);
+	efi_status = BS->HandleProtocol(http_handle, &EFI_HTTP_PROTOCOL_GUID,
+					(VOID **) &http);
 	if (EFI_ERROR(efi_status)) {
 		perror(L"Failed to get http\n");
 		goto error;
diff --git a/lib/console.c b/lib/console.c
index c310d213..5193b578 100644
--- a/lib/console.c
+++ b/lib/console.c
@@ -35,7 +35,7 @@ console_get_keystroke(EFI_INPUT_KEY *key)
 	EFI_STATUS efi_status;
 
 	do {
-		gBS->WaitForEvent(1, &ci->WaitForKey, &EventIndex);
+		BS->WaitForEvent(1, &ci->WaitForKey, &EventIndex);
 		efi_status = ci->ReadKeyStroke(ci, key);
 	} while (efi_status == EFI_NOT_READY);
 
@@ -495,7 +495,7 @@ console_mode_handle(VOID)
 	UINTN rows = 0, columns = 0;
 	EFI_STATUS efi_status = EFI_SUCCESS;
 
-	efi_status = gBS->LocateProtocol(&gop_guid, NULL, (void **)&gop);
+	efi_status = BS->LocateProtocol(&gop_guid, NULL, (void **)&gop);
 	if (EFI_ERROR(efi_status)) {
 		console_error(L"Locate graphic output protocol fail", efi_status);
 		return;
@@ -679,7 +679,7 @@ setup_verbosity(VOID)
 VOID
 msleep(unsigned long msecs)
 {
-	gBS->Stall(msecs);
+	BS->Stall(msecs);
 }
 
 /* This is used in various things to determine if we should print to the
diff --git a/lib/execute.c b/lib/execute.c
index 642f94a3..0eb872e4 100644
--- a/lib/execute.c
+++ b/lib/execute.c
@@ -63,8 +63,8 @@ execute(EFI_HANDLE image, CHAR16 *name)
 	EFI_DEVICE_PATH *devpath;
 	CHAR16 *PathName;
 
-	efi_status = gBS->HandleProtocol(image, &IMAGE_PROTOCOL,
-					 (void **) &li);
+	efi_status = BS->HandleProtocol(image, &IMAGE_PROTOCOL,
+					(void **) &li);
 	if (EFI_ERROR(efi_status))
 		return efi_status;
 
@@ -72,12 +72,12 @@ execute(EFI_HANDLE image, CHAR16 *name)
 	if (EFI_ERROR(efi_status))
 		return efi_status;
 
-	efi_status = gBS->LoadImage(FALSE, image, devpath, NULL, 0, &h);
+	efi_status = BS->LoadImage(FALSE, image, devpath, NULL, 0, &h);
 	if (EFI_ERROR(efi_status))
 		goto out;
 
-	efi_status = gBS->StartImage(h, NULL, NULL);
-	gBS->UnloadImage(h);
+	efi_status = BS->StartImage(h, NULL, NULL);
+	BS->UnloadImage(h);
 
  out:
 	FreePool(PathName);
diff --git a/lib/security_policy.c b/lib/security_policy.c
index 6c42cc14..0f2569b0 100644
--- a/lib/security_policy.c
+++ b/lib/security_policy.c
@@ -123,7 +123,7 @@ security_policy_authentication (
 	 * EFI_SECURITY_VIOLATION */
 	fail_status = efi_status;
 
-	efi_status = gBS->LocateDevicePath(&SIMPLE_FS_PROTOCOL, &DevPath, &h);
+	efi_status = BS->LocateDevicePath(&SIMPLE_FS_PROTOCOL, &DevPath, &h);
 	if (EFI_ERROR(efi_status))
 		goto out;
 
diff --git a/lib/shell.c b/lib/shell.c
index 146d9a21..8be4fe08 100644
--- a/lib/shell.c
+++ b/lib/shell.c
@@ -16,7 +16,7 @@ argsplit(EFI_HANDLE image, int *argc, CHAR16*** ARGV)
 
 	*argc = 0;
 
-	efi_status = gBS->HandleProtocol(image, &LoadedImageProtocol,
+	efi_status = BS->HandleProtocol(image, &LoadedImageProtocol,
 					 (VOID **) &info);
 	if (EFI_ERROR(efi_status)) {
 		console_print(L"Failed to get arguments\n");
diff --git a/lib/simple_file.c b/lib/simple_file.c
index 5fd3e1a6..f22852d4 100644
--- a/lib/simple_file.c
+++ b/lib/simple_file.c
@@ -11,8 +11,8 @@ simple_file_open_by_handle(EFI_HANDLE device, CHAR16 *name, EFI_FILE **file, UIN
 	EFI_FILE_IO_INTERFACE *drive;
 	EFI_FILE *root;
 
-	efi_status = gBS->HandleProtocol(device, &EFI_SIMPLE_FILE_SYSTEM_GUID,
-					 (void **)&drive);
+	efi_status = BS->HandleProtocol(device, &EFI_SIMPLE_FILE_SYSTEM_GUID,
+					(void **)&drive);
 	if (EFI_ERROR(efi_status)) {
 		console_print(L"Unable to find simple file protocol (%d)\n",
 			      efi_status);
@@ -40,8 +40,8 @@ simple_file_open(EFI_HANDLE image, CHAR16 *name, EFI_FILE **file, UINT64 mode)
 	EFI_DEVICE_PATH *loadpath = NULL;
 	CHAR16 *PathName = NULL;
 
-	efi_status = gBS->HandleProtocol(image, &IMAGE_PROTOCOL,
-					 (void **) &li);
+	efi_status = BS->HandleProtocol(image, &IMAGE_PROTOCOL,
+					(void **) &li);
 	if (EFI_ERROR(efi_status))
 		return simple_file_open_by_handle(image, name, file, mode);
 
@@ -176,9 +176,9 @@ simple_volume_selector(CHAR16 **title, CHAR16 **selected, EFI_HANDLE *h)
 	CHAR16 **entries;
 	int val;
 
-	efi_status = gBS->LocateHandleBuffer(ByProtocol,
-					     &EFI_SIMPLE_FILE_SYSTEM_GUID,
-					     NULL, &count, &vol_handles);
+	efi_status = BS->LocateHandleBuffer(ByProtocol,
+					    &EFI_SIMPLE_FILE_SYSTEM_GUID,
+					    NULL, &count, &vol_handles);
 	if (EFI_ERROR(efi_status))
 		return efi_status;
 	if (!count || !vol_handles)
@@ -196,9 +196,9 @@ simple_volume_selector(CHAR16 **title, CHAR16 **selected, EFI_HANDLE *h)
 		CHAR16 *name;
 		EFI_FILE_IO_INTERFACE *drive;
 
-		efi_status = gBS->HandleProtocol(vol_handles[i],
-					       &EFI_SIMPLE_FILE_SYSTEM_GUID,
-						 (void **) &drive);
+		efi_status = BS->HandleProtocol(vol_handles[i],
+						&EFI_SIMPLE_FILE_SYSTEM_GUID,
+						(void **) &drive);
 		if (EFI_ERROR(efi_status) || !drive)
 			continue;
 
diff --git a/mok.c b/mok.c
index 84e51f3e..af1756c2 100644
--- a/mok.c
+++ b/mok.c
@@ -16,8 +16,8 @@ static BOOLEAN check_var(CHAR16 *varname)
 	UINT32 MokVar;
 	UINT32 attributes;
 
-	efi_status = gRT->GetVariable(varname, &SHIM_LOCK_GUID, &attributes,
-				      &size, (void *)&MokVar);
+	efi_status = RT->GetVariable(varname, &SHIM_LOCK_GUID, &attributes,
+				     &size, (void *)&MokVar);
 	if (!EFI_ERROR(efi_status) || efi_status == EFI_BUFFER_TOO_SMALL)
 		return TRUE;
 
@@ -27,7 +27,7 @@ static BOOLEAN check_var(CHAR16 *varname)
 #define SetVariable(name, guid, attrs, varsz, var)                                  \
 	({                                                                          \
 		EFI_STATUS efi_status_;                                             \
-		efi_status_ = gRT->SetVariable(name, guid, attrs, varsz, var);      \
+		efi_status_ = RT->SetVariable(name, guid, attrs, varsz, var);       \
 		dprint_(L"%a:%d:%a() SetVariable(\"%s\", ... varsz=0x%llx) = %r\n", \
 		        __FILE__, __LINE__ - 5, __func__, name, varsz,              \
 		        efi_status_);                                               \
@@ -273,16 +273,16 @@ get_max_var_sz(UINT32 attrs, SIZE_T *max_var_szp)
 	uint64_t max_var_sz = 0;
 
 	*max_var_szp = 0;
-	if (EFI_MAJOR_VERSION(gRT) < 2) {
+	if (EFI_MAJOR_VERSION(RT) < 2) {
 		dprint(L"EFI %d.%d; no RT->QueryVariableInfo().  Using 1024!\n",
-		       EFI_MAJOR_VERSION(gRT), EFI_MINOR_VERSION(gRT));
+		       EFI_MAJOR_VERSION(RT), EFI_MINOR_VERSION(RT));
 		max_var_sz = remaining_sz = max_storage_sz = 1024;
 		efi_status = EFI_SUCCESS;
 	} else {
 		dprint(L"calling RT->QueryVariableInfo() at 0x%lx\n",
-		       gRT->QueryVariableInfo);
-		efi_status = gRT->QueryVariableInfo(attrs, &max_storage_sz,
-						    &remaining_sz, &max_var_sz);
+		       RT->QueryVariableInfo);
+		efi_status = RT->QueryVariableInfo(attrs, &max_storage_sz,
+						   &remaining_sz, &max_var_sz);
 		if (EFI_ERROR(efi_status)) {
 			perror(L"Could not get variable storage info: %r\n",
 			       efi_status);
@@ -1016,10 +1016,9 @@ EFI_STATUS import_mok_state(EFI_HANDLE image_handle)
 		config_sz += sizeof(config_template);
 		npages = ALIGN_VALUE(config_sz, PAGE_SIZE) >> EFI_PAGE_SHIFT;
 		config_table = NULL;
-		efi_status = gBS->AllocatePages(AllocateAnyPages,
-						EfiBootServicesData,
-						npages,
-						(EFI_PHYSICAL_ADDRESS *)&config_table);
+		efi_status = BS->AllocatePages(
+			AllocateAnyPages, EfiBootServicesData, npages,
+			(EFI_PHYSICAL_ADDRESS *)&config_table);
 		if (EFI_ERROR(efi_status) || !config_table) {
 			console_print(L"Allocating %lu pages for mok config table failed: %r\n",
 				      npages, efi_status);
@@ -1050,8 +1049,8 @@ EFI_STATUS import_mok_state(EFI_HANDLE image_handle)
 		ZeroMem(&config_template, sizeof(config_template));
 		CopyMem(p, &config_template, sizeof(config_template));
 
-		efi_status = gBS->InstallConfigurationTable(&MOK_VARIABLE_STORE,
-							    config_table);
+		efi_status = BS->InstallConfigurationTable(&MOK_VARIABLE_STORE,
+		                                           config_table);
 		if (EFI_ERROR(efi_status)) {
 			console_print(L"Couldn't install MoK configuration table\n");
 		}
diff --git a/netboot.c b/netboot.c
index 3f5c5198..cf5882c1 100644
--- a/netboot.c
+++ b/netboot.c
@@ -36,8 +36,8 @@ BOOLEAN findNetboot(EFI_HANDLE device)
 {
 	EFI_STATUS efi_status;
 
-	efi_status = gBS->HandleProtocol(device, &PxeBaseCodeProtocol,
-					 (VOID **) &pxe);
+	efi_status = BS->HandleProtocol(device, &PxeBaseCodeProtocol,
+					(VOID **) &pxe);
 	if (EFI_ERROR(efi_status)) {
 		pxe = NULL;
 		return FALSE;
diff --git a/pe.c b/pe.c
index 13bc3975..5db45086 100644
--- a/pe.c
+++ b/pe.c
@@ -949,8 +949,8 @@ handle_image (void *data, unsigned int datasize,
 				 PAGE_SIZE);
 	*alloc_pages = alloc_size / PAGE_SIZE;
 
-	efi_status = gBS->AllocatePages(AllocateAnyPages, EfiLoaderCode,
-					*alloc_pages, alloc_address);
+	efi_status = BS->AllocatePages(AllocateAnyPages, EfiLoaderCode,
+				       *alloc_pages, alloc_address);
 	if (EFI_ERROR(efi_status)) {
 		perror(L"Failed to allocate image buffer\n");
 		return EFI_OUT_OF_RESOURCES;
@@ -963,7 +963,7 @@ handle_image (void *data, unsigned int datasize,
 	*entry_point = ImageAddress(buffer, context.ImageSize, context.EntryPoint);
 	if (!*entry_point) {
 		perror(L"Entry point is invalid\n");
-		gBS->FreePages(*alloc_address, *alloc_pages);
+		BS->FreePages(*alloc_address, *alloc_pages);
 		return EFI_UNSUPPORTED;
 	}
 
@@ -1004,7 +1004,7 @@ handle_image (void *data, unsigned int datasize,
 
 		if (end < base) {
 			perror(L"Section %d has negative size\n", i);
-			gBS->FreePages(*alloc_address, *alloc_pages);
+			BS->FreePages(*alloc_address, *alloc_pages);
 			return EFI_UNSUPPORTED;
 		}
 
diff --git a/replacements.c b/replacements.c
index daa2e0f4..bf781a8b 100644
--- a/replacements.c
+++ b/replacements.c
@@ -50,7 +50,7 @@ unhook_system_services(void)
 #if !defined(DISABLE_EBS_PROTECTION)
 	systab->BootServices->ExitBootServices = system_exit_boot_services;
 #endif /* !defined(DISABLE_EBS_PROTECTION) */
-	gBS = systab->BootServices;
+	BS = systab->BootServices;
 }
 
 static EFI_STATUS EFIAPI
@@ -61,8 +61,8 @@ load_image(BOOLEAN BootPolicy, EFI_HANDLE ParentImageHandle,
 	EFI_STATUS efi_status;
 
 	unhook_system_services();
-	efi_status = gBS->LoadImage(BootPolicy, ParentImageHandle, DevicePath,
-				    SourceBuffer, SourceSize, ImageHandle);
+	efi_status = BS->LoadImage(BootPolicy, ParentImageHandle, DevicePath,
+				   SourceBuffer, SourceSize, ImageHandle);
 	hook_system_services(systab);
 	if (EFI_ERROR(efi_status))
 		last_loaded_image = NULL;
@@ -81,7 +81,7 @@ replacement_start_image(EFI_HANDLE image_handle, UINTN *exit_data_size, CHAR16 *
 		loader_is_participating = 1;
 		uninstall_shim_protocols();
 	}
-	efi_status = gBS->StartImage(image_handle, exit_data_size, exit_data);
+	efi_status = BS->StartImage(image_handle, exit_data_size, exit_data);
 	if (EFI_ERROR(efi_status)) {
 		if (image_handle == last_loaded_image) {
 			EFI_STATUS efi_status2 = install_shim_protocols();
@@ -91,9 +91,9 @@ replacement_start_image(EFI_HANDLE image_handle, UINTN *exit_data_size, CHAR16 *
 					      efi_status2);
 				console_print(L"shim cannot continue, sorry.\n");
 				msleep(5000000);
-				gRT->ResetSystem(EfiResetShutdown,
-						 EFI_SECURITY_VIOLATION,
-						 0, NULL);
+				RT->ResetSystem(EfiResetShutdown,
+						EFI_SECURITY_VIOLATION,
+						0, NULL);
 			}
 		}
 		hook_system_services(systab);
@@ -110,7 +110,7 @@ exit_boot_services(EFI_HANDLE image_key, UINTN map_key)
 	    verification_method == VERIFIED_BY_HASH) {
 		unhook_system_services();
 		EFI_STATUS efi_status;
-		efi_status = gBS->ExitBootServices(image_key, map_key);
+		efi_status = BS->ExitBootServices(image_key, map_key);
 		if (EFI_ERROR(efi_status))
 			hook_system_services(systab);
 		return efi_status;
@@ -119,7 +119,7 @@ exit_boot_services(EFI_HANDLE image_key, UINTN map_key)
 	console_print(L"Bootloader has not verified loaded image.\n");
 	console_print(L"System is compromised.  halting.\n");
 	msleep(5000000);
-	gRT->ResetSystem(EfiResetShutdown, EFI_SECURITY_VIOLATION, 0, NULL);
+	RT->ResetSystem(EfiResetShutdown, EFI_SECURITY_VIOLATION, 0, NULL);
 	return EFI_SECURITY_VIOLATION;
 }
 #endif /* !defined(DISABLE_EBS_PROTECTION) */
@@ -134,8 +134,8 @@ do_exit(EFI_HANDLE ImageHandle, EFI_STATUS ExitStatus,
 
 	restore_loaded_image();
 
-	efi_status = gBS->Exit(ImageHandle, ExitStatus,
-			       ExitDataSize, ExitData);
+	efi_status = BS->Exit(ImageHandle, ExitStatus,
+			      ExitDataSize, ExitData);
 	if (EFI_ERROR(efi_status)) {
 		EFI_STATUS efi_status2 = shim_init();
 
@@ -144,8 +144,8 @@ do_exit(EFI_HANDLE ImageHandle, EFI_STATUS ExitStatus,
 				      efi_status2);
 			console_print(L"shim cannot continue, sorry.\n");
 			msleep(5000000);
-			gRT->ResetSystem(EfiResetShutdown,
-					 EFI_SECURITY_VIOLATION, 0, NULL);
+			RT->ResetSystem(EfiResetShutdown,
+					EFI_SECURITY_VIOLATION, 0, NULL);
 		}
 	}
 	return efi_status;
@@ -155,7 +155,7 @@ void
 hook_system_services(EFI_SYSTEM_TABLE *local_systab)
 {
 	systab = local_systab;
-	gBS = systab->BootServices;
+	BS = systab->BootServices;
 
 	/* We need to hook various calls to make this work... */
 
@@ -186,14 +186,14 @@ void
 unhook_exit(void)
 {
 	systab->BootServices->Exit = system_exit;
-	gBS = systab->BootServices;
+	BS = systab->BootServices;
 }
 
 void
 hook_exit(EFI_SYSTEM_TABLE *local_systab)
 {
 	systab = local_systab;
-	gBS = local_systab->BootServices;
+	BS = local_systab->BootServices;
 
 	/* we need to hook Exit() so that we can allow users to quit the
 	 * bootloader and still e.g. start a new one or run an internal
diff --git a/shim.c b/shim.c
index 1e774f71..19b78b1b 100644
--- a/shim.c
+++ b/shim.c
@@ -721,8 +721,8 @@ should_use_fallback(EFI_HANDLE image_handle)
 	EFI_STATUS efi_status;
 	int ret = 0;
 
-	efi_status = gBS->HandleProtocol(image_handle, &EFI_LOADED_IMAGE_GUID,
-					 (void **)&li);
+	efi_status = BS->HandleProtocol(image_handle, &EFI_LOADED_IMAGE_GUID,
+					(void **)&li);
 	if (EFI_ERROR(efi_status)) {
 		perror(L"Could not get image for boot" EFI_ARCH L".efi: %r\n",
 		       efi_status);
@@ -746,8 +746,8 @@ should_use_fallback(EFI_HANDLE image_handle)
 	if (pathlen < 5 || StrCaseCmp(bootpath + pathlen - 4, L".EFI"))
 		goto error;
 
-	efi_status = gBS->HandleProtocol(li->DeviceHandle, &FileSystemProtocol,
-					 (void **) &fio);
+	efi_status = BS->HandleProtocol(li->DeviceHandle, &FileSystemProtocol,
+					(void **) &fio);
 	if (EFI_ERROR(efi_status)) {
 		perror(L"Could not get fio for li->DeviceHandle: %r\n",
 		       efi_status);
@@ -803,8 +803,8 @@ static EFI_STATUS load_image (EFI_LOADED_IMAGE *li, void **data,
 	/*
 	 * Open the device
 	 */
-	efi_status = gBS->HandleProtocol(device, &EFI_SIMPLE_FILE_SYSTEM_GUID,
-					 (void **) &drive);
+	efi_status = BS->HandleProtocol(device, &EFI_SIMPLE_FILE_SYSTEM_GUID,
+					(void **) &drive);
 	if (EFI_ERROR(efi_status)) {
 		perror(L"Failed to find fs: %r\n", efi_status);
 		goto error;
@@ -1004,8 +1004,8 @@ EFI_STATUS start_image(EFI_HANDLE image_handle, CHAR16 *ImagePath)
 	 * We need to refer to the loaded image protocol on the running
 	 * binary in order to find our path
 	 */
-	efi_status = gBS->HandleProtocol(image_handle, &EFI_LOADED_IMAGE_GUID,
-					 (void **)&shim_li);
+	efi_status = BS->HandleProtocol(image_handle, &EFI_LOADED_IMAGE_GUID,
+					(void **)&shim_li);
 	if (EFI_ERROR(efi_status)) {
 		perror(L"Unable to init protocol\n");
 		return efi_status;
@@ -1156,8 +1156,8 @@ EFI_STATUS set_second_stage (EFI_HANDLE image_handle)
 	load_options = NULL;
 	load_options_size = 0;
 
-	efi_status = gBS->HandleProtocol(image_handle, &LoadedImageProtocol,
-					 (void **) &li);
+	efi_status = BS->HandleProtocol(image_handle, &LoadedImageProtocol,
+					(void **) &li);
 	if (EFI_ERROR(efi_status)) {
 		perror (L"Failed to get load options: %r\n", efi_status);
 		return efi_status;
@@ -1245,10 +1245,10 @@ install_shim_protocols(void)
 	/*
 	 * Install the protocol
 	 */
-	efi_status = gBS->InstallProtocolInterface(&shim_lock_handle,
-						   &SHIM_LOCK_GUID,
-						   EFI_NATIVE_INTERFACE,
-						   &shim_lock_interface);
+	efi_status = BS->InstallProtocolInterface(&shim_lock_handle,
+						  &SHIM_LOCK_GUID,
+						  EFI_NATIVE_INTERFACE,
+						  &shim_lock_interface);
 	if (EFI_ERROR(efi_status)) {
 		console_error(L"Could not install security protocol",
 			      efi_status);
@@ -1274,8 +1274,8 @@ uninstall_shim_protocols(void)
 	/*
 	 * If we're back here then clean everything up before exiting
 	 */
-	gBS->UninstallProtocolInterface(shim_lock_handle, &SHIM_LOCK_GUID,
-					&shim_lock_interface);
+	BS->UninstallProtocolInterface(shim_lock_handle, &SHIM_LOCK_GUID,
+				       &shim_lock_interface);
 
 	if (!secure_mode())
 		return;
@@ -1429,7 +1429,7 @@ devel_egress(devel_egress_action action UNUSED)
 	console_print(L"\ndoing %a\n", action);
 
 	if (action == COLD_RESET)
-		gRT->ResetSystem(EfiResetCold, EFI_SECURITY_VIOLATION, 0, NULL);
+		RT->ResetSystem(EfiResetCold, EFI_SECURITY_VIOLATION, 0, NULL);
 #endif
 }
 
@@ -1556,8 +1556,8 @@ die:
 		devel_egress(COLD_RESET);
 #else
 		msleep(5000000);
-		gRT->ResetSystem(EfiResetShutdown, EFI_SECURITY_VIOLATION,
-				 0, NULL);
+		RT->ResetSystem(EfiResetShutdown, EFI_SECURITY_VIOLATION,
+				0, NULL);
 #endif
 	}