Add CryptoPkg (from UDK2010.UP3)
git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@10987 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
42
CryptoPkg/Library/BaseCryptLib/SysCall/BaseMemAllocation.c
Normal file
42
CryptoPkg/Library/BaseCryptLib/SysCall/BaseMemAllocation.c
Normal file
@@ -0,0 +1,42 @@
|
||||
/** @file
|
||||
Base Memory Allocation Routines Wrapper for Crypto library over OpenSSL
|
||||
during PEI & DXE phases.
|
||||
|
||||
Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
|
||||
This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
**/
|
||||
|
||||
#include <OpenSslSupport.h>
|
||||
|
||||
//
|
||||
// -- Memory-Allocation Routines --
|
||||
//
|
||||
|
||||
/* Allocates memory blocks */
|
||||
void *malloc (size_t size)
|
||||
{
|
||||
return AllocatePool ((UINTN)size);
|
||||
}
|
||||
|
||||
/* Reallocate memory blocks */
|
||||
void *realloc (void *ptr, size_t size)
|
||||
{
|
||||
//
|
||||
// BUG: hardcode OldSize == size! We have no any knowledge about
|
||||
// memory size of original pointer ptr.
|
||||
//
|
||||
return ReallocatePool ((UINTN)size, (UINTN)size, ptr);
|
||||
}
|
||||
|
||||
/* De-allocates or frees a memory block */
|
||||
void free (void *ptr)
|
||||
{
|
||||
FreePool (ptr);
|
||||
}
|
281
CryptoPkg/Library/BaseCryptLib/SysCall/CrtWrapper.c
Normal file
281
CryptoPkg/Library/BaseCryptLib/SysCall/CrtWrapper.c
Normal file
@@ -0,0 +1,281 @@
|
||||
/** @file
|
||||
C Run-Time Libraries (CRT) Wrapper Implementation for OpenSSL-based
|
||||
Cryptographic Library.
|
||||
|
||||
Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
|
||||
This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
**/
|
||||
|
||||
#include <OpenSslSupport.h>
|
||||
|
||||
typedef
|
||||
INTN
|
||||
(*SORT_COMPARE)(
|
||||
IN VOID *Buffer1,
|
||||
IN VOID *Buffer2
|
||||
);
|
||||
|
||||
//
|
||||
// Duplicated from EDKII BaseSortLib for qsort() wrapper
|
||||
//
|
||||
STATIC
|
||||
VOID
|
||||
QuickSortWorker (
|
||||
IN OUT VOID *BufferToSort,
|
||||
IN CONST UINTN Count,
|
||||
IN CONST UINTN ElementSize,
|
||||
IN SORT_COMPARE CompareFunction,
|
||||
IN VOID *Buffer
|
||||
)
|
||||
{
|
||||
VOID *Pivot;
|
||||
UINTN LoopCount;
|
||||
UINTN NextSwapLocation;
|
||||
|
||||
ASSERT(BufferToSort != NULL);
|
||||
ASSERT(CompareFunction != NULL);
|
||||
ASSERT(Buffer != NULL);
|
||||
|
||||
if (Count < 2 || ElementSize < 1) {
|
||||
return;
|
||||
}
|
||||
|
||||
NextSwapLocation = 0;
|
||||
|
||||
//
|
||||
// Pick a pivot (we choose last element)
|
||||
//
|
||||
Pivot = ((UINT8 *)BufferToSort + ((Count - 1) * ElementSize));
|
||||
|
||||
//
|
||||
// Now get the pivot such that all on "left" are below it
|
||||
// and everything "right" are above it
|
||||
//
|
||||
for (LoopCount = 0; LoopCount < Count - 1; LoopCount++)
|
||||
{
|
||||
//
|
||||
// If the element is less than the pivot
|
||||
//
|
||||
if (CompareFunction ((VOID *)((UINT8 *)BufferToSort + ((LoopCount) * ElementSize)), Pivot) <= 0) {
|
||||
//
|
||||
// Swap
|
||||
//
|
||||
CopyMem (Buffer, (UINT8 *)BufferToSort + (NextSwapLocation * ElementSize), ElementSize);
|
||||
CopyMem ((UINT8 *)BufferToSort + (NextSwapLocation * ElementSize), (UINT8 *)BufferToSort + ((LoopCount) * ElementSize), ElementSize);
|
||||
CopyMem ((UINT8 *)BufferToSort + ((LoopCount) * ElementSize), Buffer, ElementSize);
|
||||
|
||||
//
|
||||
// Increment NextSwapLocation
|
||||
//
|
||||
NextSwapLocation++;
|
||||
}
|
||||
}
|
||||
//
|
||||
// Swap pivot to it's final position (NextSwapLocaiton)
|
||||
//
|
||||
CopyMem (Buffer, Pivot, ElementSize);
|
||||
CopyMem (Pivot, (UINT8 *)BufferToSort + (NextSwapLocation * ElementSize), ElementSize);
|
||||
CopyMem ((UINT8 *)BufferToSort + (NextSwapLocation * ElementSize), Buffer, ElementSize);
|
||||
|
||||
//
|
||||
// Now recurse on 2 paritial lists. Neither of these will have the 'pivot' element.
|
||||
// IE list is sorted left half, pivot element, sorted right half...
|
||||
//
|
||||
QuickSortWorker (
|
||||
BufferToSort,
|
||||
NextSwapLocation,
|
||||
ElementSize,
|
||||
CompareFunction,
|
||||
Buffer
|
||||
);
|
||||
|
||||
QuickSortWorker (
|
||||
(UINT8 *)BufferToSort + (NextSwapLocation + 1) * ElementSize,
|
||||
Count - NextSwapLocation - 1,
|
||||
ElementSize,
|
||||
CompareFunction,
|
||||
Buffer
|
||||
);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
//---------------------------------------------------------
|
||||
// Standard C Run-time Library Interface Wrapper
|
||||
//---------------------------------------------------------
|
||||
|
||||
//
|
||||
// -- String Manipulation Routines --
|
||||
//
|
||||
|
||||
/* Scan a string for the last occurrence of a character */
|
||||
char *strrchr (const char *str, int c)
|
||||
{
|
||||
char * save;
|
||||
|
||||
for (save = NULL; ; ++str) {
|
||||
if (*str == c) {
|
||||
save = (char *)str;
|
||||
}
|
||||
if (*str == 0) {
|
||||
return (save);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Read formatted data from a string */
|
||||
int sscanf (const char *buffer, const char *format, ...)
|
||||
{
|
||||
//
|
||||
// Null sscanf() function implementation to satisfy the linker, since
|
||||
// no direct functionality logic dependency in present UEFI cases.
|
||||
//
|
||||
return 0;
|
||||
}
|
||||
|
||||
//
|
||||
// -- Character Classification Routines --
|
||||
//
|
||||
|
||||
/* Determines if a particular character is a decimal-digit character */
|
||||
int isdigit (int c)
|
||||
{
|
||||
//
|
||||
// <digit> ::= [0-9]
|
||||
//
|
||||
return (('0' <= (c)) && ((c) <= '9'));
|
||||
}
|
||||
|
||||
/* Determine if an integer represents character that is a hex digit */
|
||||
int isxdigit (int c)
|
||||
{
|
||||
//
|
||||
// <hexdigit> ::= [0-9] | [a-f] | [A-F]
|
||||
//
|
||||
return ((('0' <= (c)) && ((c) <= '9')) ||
|
||||
(('a' <= (c)) && ((c) <= 'f')) ||
|
||||
(('A' <= (c)) && ((c) <= 'F')));
|
||||
}
|
||||
|
||||
/* Determines if a particular character represents a space character */
|
||||
int isspace (int c)
|
||||
{
|
||||
//
|
||||
// <space> ::= [ ]
|
||||
//
|
||||
return ((c) == ' ');
|
||||
}
|
||||
|
||||
/* Determine if a particular character is an alphanumeric character */
|
||||
int isalnum (int c)
|
||||
{
|
||||
//
|
||||
// <alnum> ::= [0-9] | [a-z] | [A-Z]
|
||||
//
|
||||
return ((('0' <= (c)) && ((c) <= '9')) ||
|
||||
(('a' <= (c)) && ((c) <= 'z')) ||
|
||||
(('A' <= (c)) && ((c) <= 'Z')));
|
||||
}
|
||||
|
||||
/* Determines if a particular character is in upper case */
|
||||
int isupper (int c)
|
||||
{
|
||||
//
|
||||
// <uppercase letter> := [A-Z]
|
||||
//
|
||||
return (('A' <= (c)) && ((c) <= 'Z'));
|
||||
}
|
||||
|
||||
//
|
||||
// -- Data Conversion Routines --
|
||||
//
|
||||
|
||||
/* Convert strings to a long-integer value */
|
||||
long strtol (const char *nptr, char **endptr, int base)
|
||||
{
|
||||
//
|
||||
// Null strtol() function implementation to satisfy the linker, since there is
|
||||
// no direct functionality logic dependency in present UEFI cases.
|
||||
//
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Convert strings to an unsigned long-integer value */
|
||||
unsigned long strtoul (const char *nptr, char **endptr, int base)
|
||||
{
|
||||
//
|
||||
// Null strtoul() function implementation to satisfy the linker, since there is
|
||||
// no direct functionality logic dependency in present UEFI cases.
|
||||
//
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Convert character to lowercase */
|
||||
int tolower (int c)
|
||||
{
|
||||
if (('A' <= (c)) && ((c) <= 'Z')) {
|
||||
return (c - ('A' - 'a'));
|
||||
}
|
||||
return (c);
|
||||
}
|
||||
|
||||
//
|
||||
// -- Searching and Sorting Routines --
|
||||
//
|
||||
|
||||
/* Performs a quick sort */
|
||||
void qsort (void *base, size_t num, size_t width, int (*compare)(const void *, const void *))
|
||||
{
|
||||
VOID *Buffer;
|
||||
|
||||
ASSERT (base != NULL);
|
||||
ASSERT (compare != NULL);
|
||||
|
||||
Buffer = AllocatePool (width);
|
||||
ASSERT (Buffer != NULL);
|
||||
|
||||
//
|
||||
// Re-use PerformQuickSort() function Implementation in EDKII BaseSortLib.
|
||||
//
|
||||
QuickSortWorker (base, (UINTN)num, (UINTN)width, (SORT_COMPARE)compare, Buffer);
|
||||
|
||||
FreePool (Buffer);
|
||||
return;
|
||||
}
|
||||
|
||||
//
|
||||
// -- Process and Environment Control Routines --
|
||||
//
|
||||
|
||||
/* Get a value from the current environment */
|
||||
char *getenv (const char *varname)
|
||||
{
|
||||
//
|
||||
// Null getenv() function implementation to satisfy the linker, since there is
|
||||
// no direct functionality logic dependency in present UEFI cases.
|
||||
//
|
||||
return NULL;
|
||||
}
|
||||
|
||||
//
|
||||
// -- Stream I/O Routines --
|
||||
//
|
||||
|
||||
/* Write formatted output using a pointer to a list of arguments */
|
||||
int vfprintf (FILE *stream, const char *format, VA_LIST arg)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Write data to a stream */
|
||||
size_t fwrite (const void *buffer, size_t size, size_t count, FILE *stream)
|
||||
{
|
||||
return 0;
|
||||
}
|
54
CryptoPkg/Library/BaseCryptLib/SysCall/HelperWrapper.c
Normal file
54
CryptoPkg/Library/BaseCryptLib/SysCall/HelperWrapper.c
Normal file
@@ -0,0 +1,54 @@
|
||||
/** @file
|
||||
Wrapper Implementation of Helper Routines produced by the C Compiler
|
||||
for the OpenSSL-based Cryptographic Library.
|
||||
|
||||
Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
|
||||
This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
**/
|
||||
|
||||
#include <OpenSslSupport.h>
|
||||
|
||||
//---------------------------------------------------------
|
||||
// Helper Routines Wrapper
|
||||
//---------------------------------------------------------
|
||||
|
||||
/* Divides a 64-bit signed value with a 64-bit signed value and returns
|
||||
a 64-bit signed quotient and reminder */
|
||||
void _aulldvrm ()
|
||||
{
|
||||
//
|
||||
// Null _aulldvrm() Math function implementation to satisfy the linker, since
|
||||
// there is no direct functionality logic dependency in present UEFI cases.
|
||||
//
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
/* Converts a scalar double-precision floating point value to a 32-bit integer */
|
||||
long _ftol2_sse (double dblSource)
|
||||
{
|
||||
//
|
||||
// OpenSSL uses this function due to using floating-point inside it.
|
||||
// It is only present in 32-bit versions of the compiler.
|
||||
// Null _ftol2_sse() function implementation to satisfy the linker, since
|
||||
// there is no direct functionality logic dependency in present UEFI cases.
|
||||
//
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Converts a scalar double-precision floating point value to a 32-bit integer */
|
||||
long _ftol2 (double dblSource)
|
||||
{
|
||||
//
|
||||
// Null _ftol2() function implementation to satisfy the linker, since
|
||||
// there is no direct functionality logic dependency in present UEFI cases.
|
||||
//
|
||||
return 0;
|
||||
}
|
59
CryptoPkg/Library/BaseCryptLib/SysCall/Ia32/Alloca.S
Normal file
59
CryptoPkg/Library/BaseCryptLib/SysCall/Ia32/Alloca.S
Normal file
@@ -0,0 +1,59 @@
|
||||
#------------------------------------------------------------------------------
|
||||
#
|
||||
# Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
|
||||
# This program and the accompanying materials
|
||||
# are licensed and made available under the terms and conditions of the BSD License
|
||||
# which accompanies this distribution. The full text of the license may be found at
|
||||
# http://opensource.org/licenses/bsd-license.php.
|
||||
#
|
||||
# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
#
|
||||
# Module Name:
|
||||
#
|
||||
# Alloca.S
|
||||
#
|
||||
# Abstract:
|
||||
#
|
||||
# Implementation for allocation of automatically reclaimed memory, which is
|
||||
# used to allocate space off the runtime stack.
|
||||
# (NOTE: There is a assumption in this code that the page size equal to 4K)
|
||||
#
|
||||
#------------------------------------------------------------------------------
|
||||
|
||||
|
||||
.686:
|
||||
.code:
|
||||
|
||||
ASM_GLOBAL ASM_PFX(_alloca)
|
||||
|
||||
#------------------------------------------------------------------------------
|
||||
#
|
||||
# void __cdecl _alloca (unsigned size)
|
||||
#
|
||||
#------------------------------------------------------------------------------
|
||||
ASM_PFX(_alloca):
|
||||
|
||||
pushl %ecx
|
||||
cmpl $0x1000, %eax
|
||||
leal 8(%esp), %ecx
|
||||
jb LastPage
|
||||
|
||||
ProbePages:
|
||||
subl $0x1000, %ecx
|
||||
subl $0x1000, %eax
|
||||
testl %eax, 0(%ecx)
|
||||
cmpl $0x1000, %eax
|
||||
jae ProbePages
|
||||
|
||||
LastPage:
|
||||
subl %eax, %ecx
|
||||
movl %esp, %eax
|
||||
testl %eax, 0(%ecx)
|
||||
|
||||
movl %ecx, %esp
|
||||
movl 0(%eax), %ecx
|
||||
movl 4(%eax), %eax
|
||||
pushl %eax
|
||||
|
||||
ret
|
83
CryptoPkg/Library/BaseCryptLib/SysCall/Ia32/MathDivU64x64.S
Normal file
83
CryptoPkg/Library/BaseCryptLib/SysCall/Ia32/MathDivU64x64.S
Normal file
@@ -0,0 +1,83 @@
|
||||
#------------------------------------------------------------------------------
|
||||
#
|
||||
# Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
|
||||
# This program and the accompanying materials
|
||||
# are licensed and made available under the terms and conditions of the BSD License
|
||||
# which accompanies this distribution. The full text of the license may be found at
|
||||
# http://opensource.org/licenses/bsd-license.php.
|
||||
#
|
||||
# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
#
|
||||
# Module Name:
|
||||
#
|
||||
# MathDivU64x64.S
|
||||
#
|
||||
# Abstract:
|
||||
#
|
||||
# 64-bit Math Worker Function.
|
||||
# Divides a 64-bit unsigned value with a 64-bit unsigned value and returns
|
||||
# a 64-bit unsigned result.
|
||||
#
|
||||
#------------------------------------------------------------------------------
|
||||
|
||||
.686:
|
||||
.code:
|
||||
|
||||
ASM_GLOBAL ASM_PFX(__udivdi3), ASM_PFX(DivU64x64Remainder)
|
||||
|
||||
#------------------------------------------------------------------------------
|
||||
#
|
||||
# void __cdecl __udivdi3 (void)
|
||||
#
|
||||
#------------------------------------------------------------------------------
|
||||
ASM_PFX(__udivdi3):
|
||||
# Original local stack when calling __udivdi3
|
||||
# -----------------
|
||||
# | |
|
||||
# |---------------|
|
||||
# | |
|
||||
# |-- Divisor --|
|
||||
# | |
|
||||
# |---------------|
|
||||
# | |
|
||||
# |-- Dividend --|
|
||||
# | |
|
||||
# |---------------|
|
||||
# | ReturnAddr** |
|
||||
# ESP---->|---------------|
|
||||
#
|
||||
|
||||
#
|
||||
# Set up the local stack for NULL Reminder pointer
|
||||
#
|
||||
xorl %eax, %eax
|
||||
push %eax
|
||||
|
||||
#
|
||||
# Set up the local stack for Divisor parameter
|
||||
#
|
||||
movl 20(%esp), %eax
|
||||
push %eax
|
||||
movl 20(%esp), %eax
|
||||
push %eax
|
||||
|
||||
#
|
||||
# Set up the local stack for Dividend parameter
|
||||
#
|
||||
movl 20(%esp), %eax
|
||||
push %eax
|
||||
movl 20(%esp), %eax
|
||||
push %eax
|
||||
|
||||
#
|
||||
# Call native DivU64x64Remainder of BaseLib
|
||||
#
|
||||
jmp ASM_PFX(DivU64x64Remainder)
|
||||
|
||||
#
|
||||
# Adjust stack
|
||||
#
|
||||
addl $20, %esp
|
||||
|
||||
ret $16
|
88
CryptoPkg/Library/BaseCryptLib/SysCall/Ia32/MathDivU64x64.c
Normal file
88
CryptoPkg/Library/BaseCryptLib/SysCall/Ia32/MathDivU64x64.c
Normal file
@@ -0,0 +1,88 @@
|
||||
/** @file
|
||||
64-bit Math Worker Function.
|
||||
The 32-bit versions of C compiler generate calls to library routines
|
||||
to handle 64-bit math. These functions use non-standard calling conventions.
|
||||
|
||||
Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
|
||||
This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
**/
|
||||
|
||||
#include <Library/BaseLib.h>
|
||||
|
||||
|
||||
/*
|
||||
* Divides a 64-bit unsigned value with a 64-bit unsigned value and returns
|
||||
* a 64-bit unsigned result.
|
||||
*/
|
||||
__declspec(naked) void __cdecl _aulldiv (void)
|
||||
{
|
||||
//
|
||||
// Wrapper Implementation over EDKII DivU64x64Reminder() routine
|
||||
// UINT64
|
||||
// EFIAPI
|
||||
// DivU64x64Remainder (
|
||||
// IN UINT64 Dividend,
|
||||
// IN UINT64 Divisor,
|
||||
// OUT UINT64 *Remainder OPTIONAL
|
||||
// )
|
||||
//
|
||||
_asm {
|
||||
|
||||
; Original local stack when calling _aulldiv
|
||||
; -----------------
|
||||
; | |
|
||||
; |---------------|
|
||||
; | |
|
||||
; |-- Divisor --|
|
||||
; | |
|
||||
; |---------------|
|
||||
; | |
|
||||
; |-- Dividend --|
|
||||
; | |
|
||||
; |---------------|
|
||||
; | ReturnAddr** |
|
||||
; ESP---->|---------------|
|
||||
;
|
||||
|
||||
;
|
||||
; Set up the local stack for NULL Reminder pointer
|
||||
;
|
||||
xor eax, eax
|
||||
push eax
|
||||
|
||||
;
|
||||
; Set up the local stack for Divisor parameter
|
||||
;
|
||||
mov eax, [esp + 20]
|
||||
push eax
|
||||
mov eax, [esp + 20]
|
||||
push eax
|
||||
|
||||
;
|
||||
; Set up the local stack for Dividend parameter
|
||||
;
|
||||
mov eax, [esp + 20]
|
||||
push eax
|
||||
mov eax, [esp + 20]
|
||||
push eax
|
||||
|
||||
;
|
||||
; Call native DivU64x64Remainder of BaseLib
|
||||
;
|
||||
call DivU64x64Remainder
|
||||
|
||||
;
|
||||
; Adjust stack
|
||||
;
|
||||
add esp, 20
|
||||
|
||||
ret 16
|
||||
}
|
||||
}
|
62
CryptoPkg/Library/BaseCryptLib/SysCall/Ia32/MathLShiftS64.S
Normal file
62
CryptoPkg/Library/BaseCryptLib/SysCall/Ia32/MathLShiftS64.S
Normal file
@@ -0,0 +1,62 @@
|
||||
#------------------------------------------------------------------------------
|
||||
#
|
||||
# Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
|
||||
# This program and the accompanying materials
|
||||
# are licensed and made available under the terms and conditions of the BSD License
|
||||
# which accompanies this distribution. The full text of the license may be found at
|
||||
# http://opensource.org/licenses/bsd-license.php.
|
||||
#
|
||||
# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
#
|
||||
# Module Name:
|
||||
#
|
||||
# MathLShiftS64.S
|
||||
#
|
||||
# Abstract:
|
||||
#
|
||||
# 64-bit Math Worker Function.
|
||||
# Shifts a 64-bit signed value left by a certain number of bits.
|
||||
#
|
||||
#------------------------------------------------------------------------------
|
||||
|
||||
.686:
|
||||
.code:
|
||||
|
||||
ASM_GLOBAL ASM_PFX(__ashldi3)
|
||||
|
||||
#------------------------------------------------------------------------------
|
||||
#
|
||||
# void __cdecl __ashldi3 (void)
|
||||
#
|
||||
#------------------------------------------------------------------------------
|
||||
ASM_PFX(__ashldi3):
|
||||
#
|
||||
# Handle shifting of 64 or more bits (return 0)
|
||||
#
|
||||
cmpb $64, %cl
|
||||
jae ReturnZero
|
||||
|
||||
#
|
||||
# Handle shifting of between 0 and 31 bits
|
||||
#
|
||||
cmpb $32, %cl
|
||||
jae More32
|
||||
shld %cl, %eax, %edx
|
||||
shl %cl, %eax
|
||||
ret
|
||||
|
||||
#
|
||||
# Handle shifting of between 32 and 63 bits
|
||||
#
|
||||
More32:
|
||||
movl %eax, %edx
|
||||
xor %eax, %eax
|
||||
and $31, %cl
|
||||
shl %cl, %edx
|
||||
ret
|
||||
|
||||
ReturnZero:
|
||||
xor %eax, %eax
|
||||
xor %edx, %edx
|
||||
ret
|
54
CryptoPkg/Library/BaseCryptLib/SysCall/Ia32/MathLShiftS64.c
Normal file
54
CryptoPkg/Library/BaseCryptLib/SysCall/Ia32/MathLShiftS64.c
Normal file
@@ -0,0 +1,54 @@
|
||||
/** @file
|
||||
64-bit Math Worker Function.
|
||||
The 32-bit versions of C compiler generate calls to library routines
|
||||
to handle 64-bit math. These functions use non-standard calling conventions.
|
||||
|
||||
Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
|
||||
This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
**/
|
||||
|
||||
|
||||
/*
|
||||
* Shifts a 64-bit signed value left by a particular number of bits.
|
||||
*/
|
||||
__declspec(naked) void __cdecl _allshl (void)
|
||||
{
|
||||
_asm {
|
||||
;
|
||||
; Handle shifting of 64 or more bits (return 0)
|
||||
;
|
||||
cmp cl, 64
|
||||
jae short ReturnZero
|
||||
|
||||
;
|
||||
; Handle shifting of between 0 and 31 bits
|
||||
;
|
||||
cmp cl, 32
|
||||
jae short More32
|
||||
shld edx, eax, cl
|
||||
shl eax, cl
|
||||
ret
|
||||
|
||||
;
|
||||
; Handle shifting of between 32 and 63 bits
|
||||
;
|
||||
More32:
|
||||
mov edx, eax
|
||||
xor eax, eax
|
||||
and cl, 31
|
||||
shl edx, cl
|
||||
ret
|
||||
|
||||
ReturnZero:
|
||||
xor eax,eax
|
||||
xor edx,edx
|
||||
ret
|
||||
}
|
||||
}
|
77
CryptoPkg/Library/BaseCryptLib/SysCall/Ia32/MathMultS64x64.S
Normal file
77
CryptoPkg/Library/BaseCryptLib/SysCall/Ia32/MathMultS64x64.S
Normal file
@@ -0,0 +1,77 @@
|
||||
#------------------------------------------------------------------------------
|
||||
#
|
||||
# Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
|
||||
# This program and the accompanying materials
|
||||
# are licensed and made available under the terms and conditions of the BSD License
|
||||
# which accompanies this distribution. The full text of the license may be found at
|
||||
# http://opensource.org/licenses/bsd-license.php.
|
||||
#
|
||||
# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
#
|
||||
# Module Name:
|
||||
#
|
||||
# MathMultS64x64.S
|
||||
#
|
||||
# Abstract:
|
||||
#
|
||||
# 64-bit Math Worker Function.
|
||||
# Multiplies a 64-bit signed or unsigned value by a 64-bit signed or unsigned value
|
||||
# and returns a 64-bit result
|
||||
#
|
||||
#------------------------------------------------------------------------------
|
||||
|
||||
.686:
|
||||
.code:
|
||||
|
||||
ASM_GLOBAL ASM_PFX(_mulll), ASM_PFX(MultS64x64)
|
||||
|
||||
#------------------------------------------------------------------------------
|
||||
#
|
||||
# void __cdecl __mulll (void)
|
||||
#
|
||||
#------------------------------------------------------------------------------
|
||||
ASM_PFX(__mulll):
|
||||
# Original local stack when calling __mulll
|
||||
# -----------------
|
||||
# | |
|
||||
# |---------------|
|
||||
# | |
|
||||
# |--Multiplier --|
|
||||
# | |
|
||||
# |---------------|
|
||||
# | |
|
||||
# |--Multiplicand-|
|
||||
# | |
|
||||
# |---------------|
|
||||
# | ReturnAddr** |
|
||||
# ESP---->|---------------|
|
||||
#
|
||||
|
||||
#
|
||||
# Set up the local stack for Multiplicand parameter
|
||||
#
|
||||
movl 16(%esp), %eax
|
||||
push %eax
|
||||
movl 16(%esp), %eax
|
||||
push %eax
|
||||
|
||||
#
|
||||
# Set up the local stack for Multiplier parameter
|
||||
#
|
||||
movl 16(%esp), %eax
|
||||
push %eax
|
||||
movl 16(%esp), %eax
|
||||
push %eax
|
||||
|
||||
#
|
||||
# Call native MulS64x64 of BaseLib
|
||||
#
|
||||
jmp ASM_PFX(MultS64x64)
|
||||
|
||||
#
|
||||
# Adjust stack
|
||||
#
|
||||
add $16, %esp
|
||||
|
||||
ret $16
|
79
CryptoPkg/Library/BaseCryptLib/SysCall/Ia32/MathMultS64x64.c
Normal file
79
CryptoPkg/Library/BaseCryptLib/SysCall/Ia32/MathMultS64x64.c
Normal file
@@ -0,0 +1,79 @@
|
||||
/** @file
|
||||
64-bit Math Worker Function.
|
||||
The 32-bit versions of C compiler generate calls to library routines
|
||||
to handle 64-bit math. These functions use non-standard calling conventions.
|
||||
|
||||
Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
|
||||
This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
**/
|
||||
|
||||
#include <Library/BaseLib.h>
|
||||
|
||||
/*
|
||||
* Multiplies a 64-bit signed or unsigned value by a 64-bit signed or unsigned value
|
||||
* and returns a 64-bit result.
|
||||
*/
|
||||
__declspec(naked) void __cdecl _allmul (void)
|
||||
{
|
||||
//
|
||||
// Wrapper Implementation over EDKII MultS64x64() routine
|
||||
// INT64
|
||||
// EFIAPI
|
||||
// MultS64x64 (
|
||||
// IN INT64 Multiplicand,
|
||||
// IN INT64 Multiplier
|
||||
// )
|
||||
//
|
||||
_asm {
|
||||
; Original local stack when calling _allmul
|
||||
; -----------------
|
||||
; | |
|
||||
; |---------------|
|
||||
; | |
|
||||
; |--Multiplier --|
|
||||
; | |
|
||||
; |---------------|
|
||||
; | |
|
||||
; |--Multiplicand-|
|
||||
; | |
|
||||
; |---------------|
|
||||
; | ReturnAddr** |
|
||||
; ESP---->|---------------|
|
||||
;
|
||||
|
||||
;
|
||||
; Set up the local stack for Multiplicand parameter
|
||||
;
|
||||
mov eax, [esp + 16]
|
||||
push eax
|
||||
mov eax, [esp + 16]
|
||||
push eax
|
||||
|
||||
;
|
||||
; Set up the local stack for Multiplier parameter
|
||||
;
|
||||
mov eax, [esp + 16]
|
||||
push eax
|
||||
mov eax, [esp + 16]
|
||||
push eax
|
||||
|
||||
;
|
||||
; Call native MulS64x64 of BaseLib
|
||||
;
|
||||
call MultS64x64
|
||||
|
||||
;
|
||||
; Adjust stack
|
||||
;
|
||||
add esp, 16
|
||||
|
||||
ret 16
|
||||
}
|
||||
}
|
66
CryptoPkg/Library/BaseCryptLib/SysCall/Ia32/MathRShiftU64.S
Normal file
66
CryptoPkg/Library/BaseCryptLib/SysCall/Ia32/MathRShiftU64.S
Normal file
@@ -0,0 +1,66 @@
|
||||
#------------------------------------------------------------------------------
|
||||
#
|
||||
# Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
|
||||
# This program and the accompanying materials
|
||||
# are licensed and made available under the terms and conditions of the BSD License
|
||||
# which accompanies this distribution. The full text of the license may be found at
|
||||
# http://opensource.org/licenses/bsd-license.php.
|
||||
#
|
||||
# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
#
|
||||
# Module Name:
|
||||
#
|
||||
# MathRShiftU64.S
|
||||
#
|
||||
# Abstract:
|
||||
#
|
||||
# 64-bit Math Worker Function.
|
||||
# Shifts a 64-bit unsigned value right by a certain number of bits.
|
||||
#
|
||||
#------------------------------------------------------------------------------
|
||||
|
||||
|
||||
.686:
|
||||
.code:
|
||||
|
||||
ASM_GLOBAL ASM_PFX(__ashrdi3)
|
||||
|
||||
#------------------------------------------------------------------------------
|
||||
#
|
||||
# void __cdecl __ashrdi3 (void)
|
||||
#
|
||||
#------------------------------------------------------------------------------
|
||||
ASM_PFX(__ashrdi3):
|
||||
#
|
||||
# Checking: Only handle 64bit shifting or more
|
||||
#
|
||||
cmpb $64, %cl
|
||||
jae _Exit
|
||||
|
||||
#
|
||||
# Handle shifting between 0 and 31 bits
|
||||
#
|
||||
cmpb $32, %cl
|
||||
jae More32
|
||||
shrd %cl, %edx, %eax
|
||||
shr %cl, %edx
|
||||
ret
|
||||
|
||||
#
|
||||
# Handle shifting of 32-63 bits
|
||||
#
|
||||
More32:
|
||||
movl %edx, %eax
|
||||
xor %edx, %edx
|
||||
and $32, %cl
|
||||
shr %cl, %eax
|
||||
ret
|
||||
|
||||
#
|
||||
# Invalid number (less then 32bits), return 0
|
||||
#
|
||||
_Exit:
|
||||
xor %eax, %eax
|
||||
xor %edx, %edx
|
||||
ret
|
57
CryptoPkg/Library/BaseCryptLib/SysCall/Ia32/MathRShiftU64.c
Normal file
57
CryptoPkg/Library/BaseCryptLib/SysCall/Ia32/MathRShiftU64.c
Normal file
@@ -0,0 +1,57 @@
|
||||
/** @file
|
||||
64-bit Math Worker Function.
|
||||
The 32-bit versions of C compiler generate calls to library routines
|
||||
to handle 64-bit math. These functions use non-standard calling conventions.
|
||||
|
||||
Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
|
||||
This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
**/
|
||||
|
||||
|
||||
/*
|
||||
* Shifts a 64-bit unsigned value right by a certain number of bits.
|
||||
*/
|
||||
__declspec(naked) void __cdecl _aullshr (void)
|
||||
{
|
||||
_asm {
|
||||
;
|
||||
; Checking: Only handle 64bit shifting or more
|
||||
;
|
||||
cmp cl, 64
|
||||
jae _Exit
|
||||
|
||||
;
|
||||
; Handle shifting between 0 and 31 bits
|
||||
;
|
||||
cmp cl, 32
|
||||
jae More32
|
||||
shrd eax, edx, cl
|
||||
shr edx, cl
|
||||
ret
|
||||
|
||||
;
|
||||
; Handle shifting of 32-63 bits
|
||||
;
|
||||
More32:
|
||||
mov eax, edx
|
||||
xor edx, edx
|
||||
and cl, 31
|
||||
shr eax, cl
|
||||
ret
|
||||
|
||||
;
|
||||
; Invalid number (less then 32bits), return 0
|
||||
;
|
||||
_Exit:
|
||||
xor eax, eax
|
||||
xor edx, edx
|
||||
ret
|
||||
}
|
||||
}
|
@@ -0,0 +1,89 @@
|
||||
#------------------------------------------------------------------------------
|
||||
#
|
||||
# Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
|
||||
# This program and the accompanying materials
|
||||
# are licensed and made available under the terms and conditions of the BSD License
|
||||
# which accompanies this distribution. The full text of the license may be found at
|
||||
# http://opensource.org/licenses/bsd-license.php.
|
||||
#
|
||||
# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
#
|
||||
# Module Name:
|
||||
#
|
||||
# MathReminderU64x64.S
|
||||
#
|
||||
# Abstract:
|
||||
#
|
||||
# 64-bit Math Worker Function.
|
||||
# Divides a 64-bit unsigned value by another 64-bit unsigned value and returns
|
||||
# the 64-bit unsigned remainder
|
||||
#
|
||||
#------------------------------------------------------------------------------
|
||||
|
||||
.686:
|
||||
.code:
|
||||
|
||||
ASM_GLOBAL ASM_PFX(__umoddi3), ASM_PFX(DivU64x64Remainder)
|
||||
|
||||
#------------------------------------------------------------------------------
|
||||
#
|
||||
# void __cdecl __umoddi3 (void)
|
||||
#
|
||||
#------------------------------------------------------------------------------
|
||||
ASM_PFX(__umoddi3):
|
||||
# Original local stack when calling __umoddi3
|
||||
# -----------------
|
||||
# | |
|
||||
# |---------------|
|
||||
# | |
|
||||
# |-- Divisor --|
|
||||
# | |
|
||||
# |---------------|
|
||||
# | |
|
||||
# |-- Dividend --|
|
||||
# | |
|
||||
# |---------------|
|
||||
# | ReturnAddr** |
|
||||
# ESP---->|---------------|
|
||||
#
|
||||
|
||||
#
|
||||
# Set up the local stack for Reminder pointer
|
||||
#
|
||||
sub $8, %esp
|
||||
push %esp
|
||||
|
||||
#
|
||||
# Set up the local stack for Divisor parameter
|
||||
#
|
||||
movl 28(%esp), %eax
|
||||
push %eax
|
||||
movl 28(%esp), %eax
|
||||
push %eax
|
||||
|
||||
#
|
||||
# Set up the local stack for Dividend parameter
|
||||
#
|
||||
movl 28(%esp), %eax
|
||||
push %eax
|
||||
movl 28(%esp), %eax
|
||||
push %eax
|
||||
|
||||
#
|
||||
# Call native DivU64x64Remainder of BaseLib
|
||||
#
|
||||
jmp ASM_PFX(DivU64x64Remainder)
|
||||
|
||||
#
|
||||
# Put the Reminder in EDX:EAX as return value
|
||||
#
|
||||
movl 20(%esp), %eax
|
||||
movl 24(%esp), %edx
|
||||
|
||||
#
|
||||
# Adjust stack
|
||||
#
|
||||
add $28, %esp
|
||||
|
||||
ret $16
|
@@ -0,0 +1,93 @@
|
||||
/** @file
|
||||
64-bit Math Worker Function.
|
||||
The 32-bit versions of C compiler generate calls to library routines
|
||||
to handle 64-bit math. These functions use non-standard calling conventions.
|
||||
|
||||
Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
|
||||
This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
**/
|
||||
|
||||
#include <Library/BaseLib.h>
|
||||
|
||||
|
||||
/*
|
||||
* Divides a 64-bit unsigned value by another 64-bit unsigned value and returns
|
||||
* the 64-bit unsigned remainder.
|
||||
*/
|
||||
__declspec(naked) void __cdecl _aullrem(void)
|
||||
{
|
||||
//
|
||||
// Wrapper Implementation over EDKII DivU64x64Remainder() routine
|
||||
// UINT64
|
||||
// EFIAPI
|
||||
// DivU64x64Remainder (
|
||||
// IN UINT64 Dividend,
|
||||
// IN UINT64 Divisor,
|
||||
// OUT UINT64 *Remainder OPTIONAL
|
||||
// )
|
||||
//
|
||||
_asm {
|
||||
; Original local stack when calling _aullrem
|
||||
; -----------------
|
||||
; | |
|
||||
; |---------------|
|
||||
; | |
|
||||
; |-- Divisor --|
|
||||
; | |
|
||||
; |---------------|
|
||||
; | |
|
||||
; |-- Dividend --|
|
||||
; | |
|
||||
; |---------------|
|
||||
; | ReturnAddr** |
|
||||
; ESP---->|---------------|
|
||||
;
|
||||
|
||||
;
|
||||
; Set up the local stack for Reminder pointer
|
||||
;
|
||||
sub esp, 8
|
||||
push esp
|
||||
|
||||
;
|
||||
; Set up the local stack for Divisor parameter
|
||||
;
|
||||
mov eax, [esp + 28]
|
||||
push eax
|
||||
mov eax, [esp + 28]
|
||||
push eax
|
||||
|
||||
;
|
||||
; Set up the local stack for Dividend parameter
|
||||
;
|
||||
mov eax, [esp + 28]
|
||||
push eax
|
||||
mov eax, [esp + 28]
|
||||
push eax
|
||||
|
||||
;
|
||||
; Call native DivU64x64Remainder of BaseLib
|
||||
;
|
||||
call DivU64x64Remainder
|
||||
|
||||
;
|
||||
; Put the Reminder in EDX:EAX as return value
|
||||
;
|
||||
mov eax, [esp + 20]
|
||||
mov edx, [esp + 24]
|
||||
|
||||
;
|
||||
; Adjust stack
|
||||
;
|
||||
add esp, 28
|
||||
|
||||
ret 16
|
||||
}
|
||||
}
|
438
CryptoPkg/Library/BaseCryptLib/SysCall/RuntimeMemAllocation.c
Normal file
438
CryptoPkg/Library/BaseCryptLib/SysCall/RuntimeMemAllocation.c
Normal file
@@ -0,0 +1,438 @@
|
||||
/** @file
|
||||
Light-weight Memory Management Routines for OpenSSL-based Crypto
|
||||
Library at Runtime Phase.
|
||||
|
||||
Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
|
||||
This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
**/
|
||||
|
||||
#include <OpenSslSupport.h>
|
||||
#include <Library/UefiBootServicesTableLib.h>
|
||||
#include <Library/UefiRuntimeLib.h>
|
||||
#include <Guid/EventGroup.h>
|
||||
|
||||
//----------------------------------------------------------------
|
||||
// Initial version. Needs further optimizations.
|
||||
//----------------------------------------------------------------
|
||||
|
||||
//
|
||||
// Definitions for Runtime Memory Operations
|
||||
//
|
||||
#define RT_PAGE_SIZE 0x200
|
||||
#define RT_PAGE_MASK 0x1FF
|
||||
#define RT_PAGE_SHIFT 9
|
||||
|
||||
#define RT_SIZE_TO_PAGES(a) (((a) >> RT_PAGE_SHIFT) + (((a) & RT_PAGE_MASK) ? 1 : 0))
|
||||
#define RT_PAGES_TO_SIZE(a) ((a) << RT_PAGE_SHIFT)
|
||||
|
||||
//
|
||||
// Page Flag Definitions
|
||||
//
|
||||
#define RT_PAGE_FREE 0x00000000
|
||||
#define RT_PAGE_USED 0x00000001
|
||||
|
||||
#define MIN_REQUIRED_BLOCKS 24
|
||||
|
||||
//
|
||||
// Memory Page Table
|
||||
//
|
||||
typedef struct {
|
||||
UINTN StartPageOffset; // Offset of the starting page allocated.
|
||||
// Only available for USED pages.
|
||||
UINT32 PageFlag; // Page Attributes.
|
||||
} RT_MEMORY_PAGE_ENTRY;
|
||||
|
||||
typedef struct {
|
||||
UINTN PageCount;
|
||||
UINTN LastEmptyPageOffset;
|
||||
UINT8 *DataAreaBase; // Pointer to data Area.
|
||||
RT_MEMORY_PAGE_ENTRY Pages[1]; // Page Table Entries.
|
||||
} RT_MEMORY_PAGE_TABLE;
|
||||
|
||||
//
|
||||
// Global Page Table for Runtime Cryptographic Provider.
|
||||
//
|
||||
RT_MEMORY_PAGE_TABLE *mRTPageTable = NULL;
|
||||
|
||||
//
|
||||
// Event for Runtime Address Conversion.
|
||||
//
|
||||
EFI_EVENT mVirtualAddressChangeEvent;
|
||||
|
||||
|
||||
/**
|
||||
Initializes pre-allocated memory pointed by ScratchBuffer for subsequent
|
||||
runtime use.
|
||||
|
||||
@param[in, out] ScratchBuffer Pointer to user-supplied memory buffer.
|
||||
@param[in] ScratchBufferSize Size of supplied buffer in bytes.
|
||||
|
||||
@retval EFI_SUCCESS Successful initialization.
|
||||
|
||||
**/
|
||||
EFI_STATUS
|
||||
InitializeScratchMemory (
|
||||
IN OUT UINT8 *ScratchBuffer,
|
||||
IN UINTN ScratchBufferSize
|
||||
)
|
||||
{
|
||||
UINTN Index;
|
||||
UINTN MemorySize;
|
||||
|
||||
//
|
||||
// Parameters Checking
|
||||
//
|
||||
if (ScratchBuffer == NULL) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
if (ScratchBufferSize < MIN_REQUIRED_BLOCKS * 1024) {
|
||||
return EFI_BUFFER_TOO_SMALL;
|
||||
}
|
||||
|
||||
mRTPageTable = (RT_MEMORY_PAGE_TABLE *)ScratchBuffer;
|
||||
|
||||
//
|
||||
// Initialize Internal Page Table for Memory Management
|
||||
//
|
||||
SetMem (mRTPageTable, ScratchBufferSize, 0xFF);
|
||||
MemorySize = ScratchBufferSize - sizeof (RT_MEMORY_PAGE_TABLE) + sizeof (RT_MEMORY_PAGE_ENTRY);
|
||||
|
||||
mRTPageTable->PageCount = MemorySize / (RT_PAGE_SIZE + sizeof (RT_MEMORY_PAGE_ENTRY));
|
||||
mRTPageTable->LastEmptyPageOffset = 0x0;
|
||||
|
||||
for (Index = 0; Index < mRTPageTable->PageCount; Index++) {
|
||||
mRTPageTable->Pages[Index].PageFlag = RT_PAGE_FREE;
|
||||
mRTPageTable->Pages[Index].StartPageOffset = 0;
|
||||
}
|
||||
|
||||
mRTPageTable->DataAreaBase = ScratchBuffer + sizeof (RT_MEMORY_PAGE_TABLE) +
|
||||
(mRTPageTable->PageCount - 1) * sizeof (RT_MEMORY_PAGE_ENTRY);
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Look-up Free memory Region for object allocation.
|
||||
|
||||
@param[in] AllocationSize Bytes to be allocated.
|
||||
|
||||
@return Return available page offset for object allocation.
|
||||
|
||||
**/
|
||||
UINTN
|
||||
LookupFreeMemRegion (
|
||||
IN UINTN AllocationSize
|
||||
)
|
||||
{
|
||||
UINTN StartPageIndex;
|
||||
UINTN Index;
|
||||
UINTN SubIndex;
|
||||
UINTN ReqPages;
|
||||
|
||||
StartPageIndex = RT_SIZE_TO_PAGES (mRTPageTable->LastEmptyPageOffset);
|
||||
ReqPages = RT_SIZE_TO_PAGES (AllocationSize);
|
||||
|
||||
//
|
||||
// Look up the free memory region with in current memory map table.
|
||||
//
|
||||
for (Index = StartPageIndex; Index <= (mRTPageTable->PageCount - ReqPages); ) {
|
||||
//
|
||||
// Check consecutive ReqPages pages.
|
||||
//
|
||||
for (SubIndex = 0; SubIndex < ReqPages; SubIndex++) {
|
||||
if ((mRTPageTable->Pages[SubIndex + Index].PageFlag & RT_PAGE_USED) != 0) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (SubIndex == ReqPages) {
|
||||
//
|
||||
// Succeed! Return the Starting Offset.
|
||||
//
|
||||
return RT_PAGES_TO_SIZE (Index);
|
||||
}
|
||||
|
||||
//
|
||||
// Failed! Skip current free memory pages and adjacent Used pages
|
||||
//
|
||||
while ((mRTPageTable->Pages[SubIndex + Index].PageFlag & RT_PAGE_USED) != 0) {
|
||||
SubIndex++;
|
||||
}
|
||||
|
||||
Index += SubIndex;
|
||||
}
|
||||
|
||||
//
|
||||
// Look up the free memory region from the beginning of the memory table
|
||||
// until the StartCursorOffset
|
||||
//
|
||||
for (Index = 0; Index < (StartPageIndex - ReqPages); ) {
|
||||
//
|
||||
// Check Consecutive ReqPages Pages.
|
||||
//
|
||||
for (SubIndex = 0; SubIndex < ReqPages; SubIndex++) {
|
||||
if ((mRTPageTable->Pages[SubIndex + Index].PageFlag & RT_PAGE_USED) != 0) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (SubIndex == ReqPages) {
|
||||
//
|
||||
// Succeed! Return the Starting Offset.
|
||||
//
|
||||
return RT_PAGES_TO_SIZE (Index);
|
||||
}
|
||||
|
||||
//
|
||||
// Failed! Skip current adjacent Used pages
|
||||
//
|
||||
while ((SubIndex < (StartPageIndex - ReqPages)) &&
|
||||
((mRTPageTable->Pages[SubIndex + Index].PageFlag & RT_PAGE_USED) != 0)) {
|
||||
SubIndex++;
|
||||
}
|
||||
|
||||
Index += SubIndex;
|
||||
}
|
||||
|
||||
//
|
||||
// No availabe region for object allocation!
|
||||
//
|
||||
return (UINTN)(-1);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Allocates a buffer at runtime phase.
|
||||
|
||||
@param[in] AllocationSize Bytes to be allocated.
|
||||
|
||||
@return A pointer to the allocated buffer or NULL if allocation fails.
|
||||
|
||||
**/
|
||||
VOID *
|
||||
RuntimeAllocateMem (
|
||||
IN UINTN AllocationSize
|
||||
)
|
||||
{
|
||||
UINT8 *AllocPtr;
|
||||
UINTN ReqPages;
|
||||
UINTN Index;
|
||||
UINTN StartPage;
|
||||
UINTN AllocOffset;
|
||||
|
||||
AllocPtr = NULL;
|
||||
ReqPages = 0;
|
||||
|
||||
//
|
||||
// Look for available consecutive memory region starting from LastEmptyPageOffset.
|
||||
// If no proper memory region found, look up from the beginning.
|
||||
// If still not found, return NULL to indicate failed allocation.
|
||||
//
|
||||
AllocOffset = LookupFreeMemRegion (AllocationSize);
|
||||
if (AllocOffset == (UINTN)(-1)) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
//
|
||||
// Allocates consecutive memory pages with length of Size. Update the page
|
||||
// table status. Returns the starting address.
|
||||
//
|
||||
ReqPages = RT_SIZE_TO_PAGES (AllocationSize);
|
||||
AllocPtr = mRTPageTable->DataAreaBase + AllocOffset;
|
||||
StartPage = RT_SIZE_TO_PAGES (AllocOffset);
|
||||
Index = 0;
|
||||
while (Index < ReqPages) {
|
||||
mRTPageTable->Pages[StartPage + Index].PageFlag |= RT_PAGE_USED;
|
||||
mRTPageTable->Pages[StartPage + Index].StartPageOffset = AllocOffset;
|
||||
|
||||
Index++;
|
||||
}
|
||||
|
||||
mRTPageTable->LastEmptyPageOffset = AllocOffset + RT_PAGES_TO_SIZE (ReqPages);
|
||||
|
||||
ZeroMem (AllocPtr, AllocationSize);
|
||||
|
||||
//
|
||||
// Returns a void pointer to the allocated space
|
||||
//
|
||||
return AllocPtr;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Frees a buffer that was previously allocated at runtime phase.
|
||||
|
||||
@param[in] Buffer Pointer to the buffer to free.
|
||||
|
||||
**/
|
||||
VOID
|
||||
RuntimeFreeMem (
|
||||
IN VOID *Buffer
|
||||
)
|
||||
{
|
||||
UINTN StartOffset;
|
||||
UINTN StartPageIndex;
|
||||
|
||||
StartOffset = (UINTN) ((UINT8 *)Buffer - mRTPageTable->DataAreaBase);
|
||||
StartPageIndex = RT_SIZE_TO_PAGES (mRTPageTable->Pages[RT_SIZE_TO_PAGES(StartOffset)].StartPageOffset);
|
||||
|
||||
while (StartPageIndex < mRTPageTable->PageCount) {
|
||||
if (((mRTPageTable->Pages[StartPageIndex].PageFlag & RT_PAGE_USED) != 0) &&
|
||||
(mRTPageTable->Pages[StartPageIndex].StartPageOffset == StartOffset)) {
|
||||
//
|
||||
// Free this page
|
||||
//
|
||||
mRTPageTable->Pages[StartPageIndex].PageFlag &= ~RT_PAGE_USED;
|
||||
mRTPageTable->Pages[StartPageIndex].PageFlag |= RT_PAGE_FREE;
|
||||
mRTPageTable->Pages[StartPageIndex].StartPageOffset = 0;
|
||||
|
||||
StartPageIndex++;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Notification function of EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE.
|
||||
|
||||
This is a notification function registered on EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE
|
||||
event. It converts a pointer to a new virtual address.
|
||||
|
||||
@param[in] Event The event whose notification function is being invoked.
|
||||
@param[in] Context The pointer to the notification function's context.
|
||||
|
||||
**/
|
||||
VOID
|
||||
EFIAPI
|
||||
RuntimeCryptLibAddressChangeEvent (
|
||||
IN EFI_EVENT Event,
|
||||
IN VOID *Context
|
||||
)
|
||||
{
|
||||
//
|
||||
// Converts a pointer for runtime memory management to a new virtual address.
|
||||
//
|
||||
EfiConvertPointer (0x0, (VOID **) &mRTPageTable->DataAreaBase);
|
||||
EfiConvertPointer (0x0, (VOID **) &mRTPageTable);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Constructor routine for runtime crypt library instance.
|
||||
|
||||
The constructor function pre-allocates space for runtime cryptographic operation.
|
||||
|
||||
@param ImageHandle The firmware allocated handle for the EFI image.
|
||||
@param SystemTable A pointer to the EFI System Table.
|
||||
|
||||
@retval EFI_SUCCESS The construction succeeded.
|
||||
@retval EFI_OUT_OF_RESOURCE Failed to allocate memory.
|
||||
|
||||
**/
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
RuntimeCryptLibConstructor (
|
||||
IN EFI_HANDLE ImageHandle,
|
||||
IN EFI_SYSTEM_TABLE *SystemTable
|
||||
)
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
VOID *Buffer;
|
||||
|
||||
//
|
||||
// Pre-allocates runtime space for possible cryptographic operations
|
||||
//
|
||||
Buffer = AllocateRuntimePool (MIN_REQUIRED_BLOCKS * 1024);
|
||||
Status = InitializeScratchMemory (Buffer, MIN_REQUIRED_BLOCKS * 1024);
|
||||
if (EFI_ERROR (Status)) {
|
||||
return Status;
|
||||
}
|
||||
|
||||
//
|
||||
// Create address change event
|
||||
//
|
||||
Status = gBS->CreateEventEx (
|
||||
EVT_NOTIFY_SIGNAL,
|
||||
TPL_NOTIFY,
|
||||
RuntimeCryptLibAddressChangeEvent,
|
||||
NULL,
|
||||
&gEfiEventVirtualAddressChangeGuid,
|
||||
&mVirtualAddressChangeEvent
|
||||
);
|
||||
ASSERT_EFI_ERROR (Status);
|
||||
|
||||
return Status;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// -- Memory-Allocation Routines Wrapper for UEFI-OpenSSL Library --
|
||||
//
|
||||
|
||||
/* Allocates memory blocks */
|
||||
void *malloc (size_t size)
|
||||
{
|
||||
return RuntimeAllocateMem ((UINTN)size);
|
||||
}
|
||||
|
||||
/* Reallocate memory blocks */
|
||||
void *realloc (void *ptr, size_t size)
|
||||
{
|
||||
VOID *NewPtr;
|
||||
UINTN StartOffset;
|
||||
UINTN StartPageIndex;
|
||||
UINTN PageCount;
|
||||
|
||||
//
|
||||
// Get Original Size of ptr
|
||||
//
|
||||
StartOffset = (UINTN) ((UINT8 *)ptr - mRTPageTable->DataAreaBase);
|
||||
StartPageIndex = RT_SIZE_TO_PAGES (mRTPageTable->Pages[RT_SIZE_TO_PAGES (StartOffset)].StartPageOffset);
|
||||
PageCount = 0;
|
||||
while (StartPageIndex < mRTPageTable->PageCount) {
|
||||
if (((mRTPageTable->Pages[StartPageIndex].PageFlag & RT_PAGE_USED) != 0) &&
|
||||
(mRTPageTable->Pages[StartPageIndex].StartPageOffset == StartOffset)) {
|
||||
StartPageIndex++;
|
||||
PageCount++;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (size <= RT_PAGES_TO_SIZE (PageCount)) {
|
||||
//
|
||||
// Return the original pointer, if Caller try to reduce region size;
|
||||
//
|
||||
return ptr;
|
||||
}
|
||||
|
||||
NewPtr = RuntimeAllocateMem ((UINTN) size);
|
||||
if (NewPtr == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
CopyMem (NewPtr, ptr, RT_PAGES_TO_SIZE (PageCount));
|
||||
|
||||
RuntimeFreeMem (ptr);
|
||||
|
||||
return NewPtr;
|
||||
}
|
||||
|
||||
/* Deallocates or frees a memory block */
|
||||
void free (void *ptr)
|
||||
{
|
||||
RuntimeFreeMem (ptr);
|
||||
}
|
102
CryptoPkg/Library/BaseCryptLib/SysCall/TimerWrapper.c
Normal file
102
CryptoPkg/Library/BaseCryptLib/SysCall/TimerWrapper.c
Normal file
@@ -0,0 +1,102 @@
|
||||
/** @file
|
||||
C Run-Time Libraries (CRT) Time Management Routines Wrapper Implementation
|
||||
for OpenSSL-based Cryptographic Library (used in DXE & RUNTIME).
|
||||
|
||||
Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>
|
||||
This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
**/
|
||||
|
||||
#include <Uefi.h>
|
||||
#include <OpenSslSupport.h>
|
||||
#include <Library/UefiRuntimeServicesTableLib.h>
|
||||
|
||||
//
|
||||
// -- Time Management Routines --
|
||||
//
|
||||
|
||||
#define IsLeap(y) (((y) % 4) == 0 && (((y) % 100) != 0 || ((y) % 400) == 0))
|
||||
#define SECSPERHOUR (60 * 60)
|
||||
#define SECSPERDAY (24 * SECSPERHOUR)
|
||||
|
||||
//
|
||||
// The arrays give the cumulative number of days up to the first of the
|
||||
// month number used as the index (1 -> 12) for regular and leap years.
|
||||
// The value at index 13 is for the whole year.
|
||||
//
|
||||
UINTN CumulativeDays[2][14] = {
|
||||
{
|
||||
0,
|
||||
0,
|
||||
31,
|
||||
31 + 28,
|
||||
31 + 28 + 31,
|
||||
31 + 28 + 31 + 30,
|
||||
31 + 28 + 31 + 30 + 31,
|
||||
31 + 28 + 31 + 30 + 31 + 30,
|
||||
31 + 28 + 31 + 30 + 31 + 30 + 31,
|
||||
31 + 28 + 31 + 30 + 31 + 30 + 31 + 31,
|
||||
31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30,
|
||||
31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31,
|
||||
31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30,
|
||||
31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30 + 31
|
||||
},
|
||||
{
|
||||
0,
|
||||
0,
|
||||
31,
|
||||
31 + 29,
|
||||
31 + 29 + 31,
|
||||
31 + 29 + 31 + 30,
|
||||
31 + 29 + 31 + 30 + 31,
|
||||
31 + 29 + 31 + 30 + 31 + 30,
|
||||
31 + 29 + 31 + 30 + 31 + 30 + 31,
|
||||
31 + 29 + 31 + 30 + 31 + 30 + 31 + 31,
|
||||
31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30,
|
||||
31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31,
|
||||
31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30,
|
||||
31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30 + 31
|
||||
}
|
||||
};
|
||||
|
||||
/* Get the system time as seconds elapsed since midnight, January 1, 1970. */
|
||||
//INTN time(
|
||||
// INTN *timer
|
||||
// )
|
||||
time_t time (time_t *timer)
|
||||
{
|
||||
EFI_TIME Time;
|
||||
UINTN Year;
|
||||
|
||||
//
|
||||
// Get the current time and date information
|
||||
//
|
||||
gRT->GetTime (&Time, NULL);
|
||||
|
||||
//
|
||||
// Years Handling
|
||||
// UTime should now be set to 00:00:00 on Jan 1 of the current year.
|
||||
//
|
||||
for (Year = 1970, *timer = 0; Year != Time.Year; Year++) {
|
||||
*timer = *timer + (time_t)(CumulativeDays[IsLeap(Year)][13] * SECSPERDAY);
|
||||
}
|
||||
|
||||
//
|
||||
// Add in number of seconds for current Month, Day, Hour, Minute, Seconds, and TimeZone adjustment
|
||||
//
|
||||
*timer = *timer +
|
||||
(time_t)((Time.TimeZone != EFI_UNSPECIFIED_TIMEZONE) ? (Time.TimeZone * 60) : 0) +
|
||||
(time_t)(CumulativeDays[IsLeap(Time.Year)][Time.Month] * SECSPERDAY) +
|
||||
(time_t)(((Time.Day > 0) ? Time.Day - 1 : 0) * SECSPERDAY) +
|
||||
(time_t)(Time.Hour * SECSPERHOUR) +
|
||||
(time_t)(Time.Minute * 60) +
|
||||
(time_t)Time.Second;
|
||||
|
||||
return *timer;
|
||||
}
|
Reference in New Issue
Block a user