cdnutter
/
iBoot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
iBoot/drivers/samsung/pke/AppleS5L8900XPKE-hardware.c

718 lines
21 KiB
C
Raw Permalink Blame History

/*
* Copyright (C) 2008 Apple Inc. All rights reserved.
*
* This document is the property of Apple Inc.
* It is considered confidential and proprietary.
*
* This document may not be reproduced or transmitted in any form,
* in whole or in part, without the express written permission of
* Apple Inc.
*/
#include <string.h>
#include "AppleS5L8900XPKE-hardware.h"
#define AppleS5L8900XPKE_hardware_DEBUG 0
#undef absolutetime_to_nanoseconds
#if AppleS5L8900XPKE_hardware_DEBUG
static void debug_data(uint8_t *data, size_t length)
{
uint32_t i=0;
printf("data %p,%d\n" , data, length);
for (i = 0; i < length; i++) {
if( !(i%256) )
printf("Seg : %p \n", data);
printf("%02X, ", *(data + i));
if ((i % 16) == 15)
printf("\n");
}
printf("\n");
}
#define debug(fmt, args...) printf("AppleS5L8900XPKE-hardware::%s: " fmt "\n", __FUNCTION__ , ##args)
#else
#define debug(fmt, args...)
#define debug_data(data, length)
#endif
#if IN_KERNEL
extern uint64_t iodelay_time[3];
static uint64_t delay_time;
#endif
uint32_t
PkeSetMode(uint32_t uSegSize)
{
uint32_t uWriteVal;
switch (uSegSize) {
case PKE_SEG_SIZE_256:
uWriteVal = PKE_REGVAL_SEG_SIZE_SEGSIZE_256;
break;
case PKE_SEG_SIZE_128:
uWriteVal = PKE_REGVAL_SEG_SIZE_SEGSIZE_128;
break;
case PKE_SEG_SIZE_64:
uWriteVal = PKE_REGVAL_SEG_SIZE_SEGSIZE_64;
break;
default:
uWriteVal = 0;
debug("error setting segment size/mode\n");
}
/* ! write SEG_SIZE and MODE_ID */
return (uWriteVal | PKE_REGMASK_SEG_SIZE_MUSTBEONE);
}
uint32_t
PkeGetSegmentCount(uint32_t uSegSize)
{
/* return segment total number */
switch (uSegSize) {
case PKE_SEG_SIZE_256:
return PKE_SEG_NUM_CASE256;
case PKE_SEG_SIZE_128:
return PKE_SEG_NUM_CASE128;
case PKE_SEG_SIZE_64:
return PKE_SEG_NUM_CASE64;
default:
return 0;
}
}
static uint32_t get_precision(uint32_t uBitLen)
{
uint32_t uPrecision;
if (uBitLen <= PKE_LEN_BIT_512) {
uPrecision = PKE_SIZE_PREC_0;
} else if ((uBitLen <= PKE_LEN_BIT_1024) && (uBitLen != PKE_LEN_BIT_672) && (uBitLen != PKE_LEN_BIT_864)) {
uPrecision = PKE_SIZE_PREC_1;
} else if ((uBitLen <= PKE_LEN_BIT_1536) && (uBitLen != PKE_LEN_BIT_1280) && (uBitLen != PKE_LEN_BIT_1408)) {
uPrecision = PKE_SIZE_PREC_2;
} else {
uPrecision = PKE_SIZE_PREC_3;
}
return uPrecision;
}
static uint32_t get_chunkSize(uint32_t uBitLen, uint32_t uPrecision)
{
uint32_t uDiv, uChunk;
switch (uPrecision) {
case PKE_SIZE_PREC_0:
if (uBitLen < PKE_LEN_BIT_128) {
uBitLen = PKE_LEN_BIT_128;
}
uDiv = uBitLen >> 5;
uChunk = uDiv;
if (uBitLen - (uChunk << 5)) {
uDiv++;
}
uChunk = --uDiv;
break;
case PKE_SIZE_PREC_1:
uDiv = uBitLen >> 6;
uChunk = uDiv;
if (uBitLen - (uChunk << 6)) {
uDiv++;
}
uChunk = --uDiv;
break;
case PKE_SIZE_PREC_2:
uDiv = (uBitLen / 3) >> 5;
uChunk = uDiv;
if (uBitLen - ((uChunk * 3) << 5)) {
uDiv++;
}
uChunk = --uDiv;
break;
case PKE_SIZE_PREC_3:
uDiv = uBitLen >> 7;
uChunk = uDiv;
if (uBitLen - (uChunk << 7)) {
uDiv++;
}
uChunk = --uDiv;
break;
default:
debug("Unsupported precision value: %u", uPrecision);
uChunk = 0;
}
return (((uChunk << 3) + 8) << 2);
}
static uint32_t
config_pke_key_len(uint32_t uBitLen)
{
uint32_t uDiv, uChunk, uPrecision;
/* 1. Get Precision */
uPrecision = get_precision(uBitLen);
/* 2. Get chunck size */
uChunk = get_chunkSize(uBitLen, uPrecision);
/* 3. Set precision and chunksize */
uDiv = ((uChunk >> 2) - 8) | uPrecision;
#if IN_KERNEL
//Set the IODelay time based on uBitLen.
if (uBitLen <= PKE_LEN_BIT_512) {
delay_time = iodelay_time[0];
}
else if (uBitLen <= PKE_LEN_BIT_1024) {
delay_time = iodelay_time[1];
}
else {
delay_time = iodelay_time[2];
}
#endif
return uDiv;
}
static inline uint32_t
RSAPkeSetInOut(uint32_t uDest, uint32_t uSrc1, uint32_t uSrc2)
{
uint32_t uPosition = 0;
/*! Set segment ID of src and dest */
uPosition = ((uSrc1 << PKE_REGSHIFT_SEG_ID_A_SEG_ID)
| (uSrc2 << PKE_REGSHIFT_SEG_ID_B_SEG_ID)
| (uDest << PKE_REGSHIFT_SEG_ID_S_SEG_ID));
return uPosition;
}
static inline bool
RSAPkeRun(volatile struct pke_regs *registers, uint32_t uCmdVal)
{
/*! Run PKE */
registers->pke_start = uCmdVal;
#if IN_KERNEL
IODelay(delay_time);
#endif
do {
if (!(registers->pke_start & PKE_REGMASK_START_EXEC_ON))
return true;
} while (1);
return false;
}
static bool shift_left(uint32_t *data, uint32_t data_size)
{
int prev_carry = 0, cur_carry = 0;
uint32_t itr = 0;
for (itr=0; itr < (data_size/sizeof(uint32_t)); itr++) {
cur_carry = data[itr] >> 31;
data[itr] = (data[itr] << 1) + prev_carry;
prev_carry = cur_carry;
}
return prev_carry;
}
static int32_t highestSetBit(uint32_t *data1, uint32_t data_size)
{
int32_t ix = data_size/sizeof(uint32_t) - 1; // Most significant word.
while( ix>=0 && data1[ix]==0) {
ix--;
}
if(ix < 0)
return -1; //mods is zero.
uint32_t msNZword = data1[ix];
uint32_t b = ((ix+1) * sizeof(uint32_t) * DATA_BYTE_TO_BIT) - 1 ;
// Now find the highest set bit.
uint32_t mask = 0x80000000;
while ((msNZword & mask) == 0) {
mask >>= 1;
b--;
}
return b;
}
static bool is_greater(uint32_t *data1, uint32_t *data2, uint32_t data_size)
{
uint32_t itr = data_size/sizeof(uint32_t) - 1; //start at the last word.
do {
if(data1[itr] > data2[itr])
return true;
else if(data1[itr] < data2[itr])
return false;
//check next word;
}while(itr--);
return false;
}
/* Do data1 = data1 - data2 */
static uint32_t sub(uint32_t *data1, uint32_t *data2, uint32_t data_size)
{
uint32_t borrow = 0;
uint32_t itr = 0;
for(itr=0; itr < (data_size/sizeof(uint32_t)); itr++) {
if(borrow) {
if(data1[itr] != 0)
borrow = 0; //No need to borrow again.
data1[itr] -= 1;
}
if( data1[itr] < data2[itr] )
borrow = 1;
data1[itr] -= data2[itr];
}
if(borrow)
return 1;
return 0;
}
/*Do data1 = data1 + data2 */
static uint32_t add(uint32_t *data1, uint32_t *data2, uint32_t data_size)
{
uint32_t temp;
int carry = 0;
uint32_t itr = 0;
for(itr=0; itr < (data_size/sizeof(uint32_t)); itr++) {
temp = data1[itr] + data2[itr] + carry;
if(temp < data1[itr] || (temp == data1[itr] && carry))
carry = 1;
else
carry = 0;
data1[itr] = temp;
}
return carry;
}
// The src buffer is assumed to be word aligned at this point.
// The hardware register is 4 byte aligned.
// The data is in little Endian.
static inline void copy_into_segment(volatile uint8_t *memory, uint32_t segment_id, uint32_t segment_size, uint8_t *data, uint32_t length)
{
volatile uint8_t *dst = memory + segment_id * segment_size;
uint32_t ii=0;
//Make sure the buffer is word aligned.
//assert((data & 3) == 0); //We don't assert in iBoot. The only interface makes sure we have aligned buffer.
uint32_t newLength = length & ~3 ;
//Copy words.
for(ii=0; ii<(newLength/4); ii++)
*((uint32_t*)dst + ii) = *((uint32_t*)data + ii);
//See if you have less than a word left to copy.
if(length & 3) { //have less than 4 bytes left to copy.
uint8_t wordData[4] = {0,0,0,0};
uint8_t *bytesLeft = data + newLength;
for(ii=0; ii<(length & 3); ii++) {
wordData[ii] = *(bytesLeft + ii);
}
*((uint32_t*)(dst+newLength)) = *((uint32_t*)wordData);
}
//zero fill the rest of the segment.
uint32_t bytesCopied = ((length+3) & ~3);
uint32_t left = segment_size - bytesCopied;
if(left) {
uint32_t *dest = (uint32_t *)(dst + bytesCopied);
for(ii=0; ii<(left/4); ii++)
*(dest+ii) = 0x00000000;
}
}
/* Calculate R0 in software.
rzero has memory allocated of size modulus_length and is zero filled.
*/
bool rsa_cal_R0(uint32_t * const mods, uint32_t modulus_length, uint32_t *rzero)
{
debug("called");
uint32_t precision = get_precision(modulus_length*DATA_BYTE_TO_BIT);
uint32_t chunk_size = get_chunkSize(modulus_length*DATA_BYTE_TO_BIT, precision);
//precision is 1,2,3,4 instead of 0,1,2,3
precision += 1;
/* Compute 2^b */
uint32_t power = (chunk_size / 16) + 1;
if (precision == 3)
power = power * 3;
power = power + (precision * (chunk_size + 16));
//compute the most significant bit set in the modulus.
int32_t b = highestSetBit((uint32_t*)mods, modulus_length);
if(b == -1)
return false;
//store 2^b in rzero.
bzero(rzero, modulus_length);
rzero[(b/32)] = 1 << (b % 32);
/* Calculate (2^(power-b) * 2^b) mod M */
uint32_t itr;
for(itr=0; itr<(power-b); itr++) {
bool carry = shift_left(rzero, modulus_length); //Shift left.
if (carry || is_greater(rzero, mods, modulus_length))
sub(rzero, (uint32_t*)mods, modulus_length);
}
return true;
}
/* Compute the value of R^2 using the hardware.
The value of rzero (R0) is calculated in softare and passed into the function
The hardware should be reset before calling this function.
The value of R^2 is returned thru' rsquare (memory for this is allocated before calling this function and of modulus_length size)
*/
static bool rsa_cal_R2modM(volatile struct pke_regs *registers, volatile uint8_t *memory, uint32_t seg_size, uint32_t * const mods, uint32_t mods_length, uint32_t *rsquare, uint32_t *r2_segid)
{
debug("called");
if(!rsquare) //Need rzero (which should be in rsquare) to proceed
return false;
//Set the key length;
registers->pke_key_len = config_pke_key_len(mods_length*DATA_BYTE_TO_BIT);
//Set segment size;
registers->pke_seg_size = PkeSetMode(seg_size);
registers->pke_seg_sign = 0;
registers->pke_seg_id = 0;
/* Use hardware to calculate R1 thru' Rn and finally R^2 */
//Load modulus always into seg0.
copy_into_segment(memory, mod_segid, seg_size, (uint8_t*)mods, mods_length);
//based on seg_size compute the seg_ids to store the (2^(power-b) * 2^b) mod M
// and the final value of R^2
uint32_t rzero_segid, rsq_segid;
switch (seg_size) {
case PKE_SEG_SIZE_256:
rzero_segid = PKE_SEG_ID_05;
rsq_segid = PKE_SEG_ID_06;
break;
case PKE_SEG_SIZE_128:
rzero_segid = PKE_SEG_ID_12;
rsq_segid = PKE_SEG_ID_14;
break;
case PKE_SEG_SIZE_64:
rzero_segid = PKE_SEG_ID_28;
rsq_segid = PKE_SEG_ID_29;
break;
default:
//Should not happen.
return false;
}
//Load the rzero into the hardware.
copy_into_segment(memory, rzero_segid, seg_size, (uint8_t*)rsquare, mods_length);
uint32_t precision = (registers->pke_key_len&PKE_REGMASK_KEY_LEN_PREC_ID) + 1;
//Compute the number of hardware iterations based on precision.
uint32_t square_count;
if (precision == 1 || precision == 3)
square_count = 4;
else if (precision == 2)
square_count = 5;
else /* precision == 4 */
square_count = 6;
//Set pre load modulus on when using the hardware for the first time.
uint32_t start_mask = PKE_REGMASK_START_PLDM_ON | PKE_REGMASK_START_EXEC_ON;
uint32_t itr = 1;
uint32_t temp_segid = rsq_segid;
while (itr <= square_count) {
//setup seg_id pointers on the hardware
registers->pke_seg_id = RSAPkeSetInOut(temp_segid, rzero_segid, rzero_segid);
//kick the hardware.
if(!RSAPkeRun(registers, start_mask))
return false;
itr++;
if(itr > square_count)
break;
//swap the segids and do the square again.
temp_segid += rzero_segid;
rzero_segid = temp_segid - rzero_segid;
temp_segid -= rzero_segid;
start_mask = PKE_REGMASK_START_EXEC_ON; //dont have to laod M again.
}
// Check the sign value of temp_segid and add modulus if negative.
uint32_t uRead, uMask;
uMask = (1 << temp_segid);
uRead = registers->pke_seg_sign & uMask;
//If negative then add modulus.
if(uRead) {
add( (uint32_t*)(memory+(temp_segid*seg_size)), (uint32_t*)mods, mods_length);
}
*r2_segid = temp_segid;
//Clean up the temp space used.
bzero((uint8_t*) memory+rzero_segid*seg_size, mods_length);
/* Reset the signbits */
registers->pke_seg_sign = 0;
memcpy(rsquare, (uint8_t *) memory+rsq_segid*seg_size, mods_length);
return true;
}
/* Calculate exponential.
The options parameter passed in indicates if R^2 is passed in or needs to be computed.
Options = 00 => Compute R^2 and don't care about caching. *rsquare is ignored.
Options = 01 => Compute R^2 and return it for caching. *rsquare has mem allocated and is of size modulus_length
Options = 10 => Use passed in R^2 value.
Reset the hardware before calling this function.
*/
bool rsa_cal_exp(void *dst, uint32_t *len, uint32_t options,
uint8_t *rsquare, uint32_t *rsquare_length,
uint8_t * const base, uint32_t base_length,
uint8_t * const expn, uint32_t expn_length,
uint8_t * const modulus, uint32_t modulus_length,
volatile struct pke_regs *registers, volatile uint8_t *memory)
{
debug("called");
/* Perform validation checks */
if(modulus_length % 4)
return false;
uint32_t segment_size, num_segments;
if (modulus_length <= (PKE_SEG_SIZE_64)) {
segment_size = PKE_SEG_SIZE_64;
} else if (modulus_length <= (PKE_SEG_SIZE_128)) {
segment_size = PKE_SEG_SIZE_128;
} else if (modulus_length <= (PKE_SEG_SIZE_256)) {
segment_size = PKE_SEG_SIZE_256;
} else
return false; /* key too long */
num_segments = PkeGetSegmentCount(segment_size);
if ( !num_segments ||
base_length > segment_size ||
expn_length > segment_size ||
modulus_length > segment_size)
return false;
/* Sane input, so proceed */
//rsquare segid must always be the last seg ID.
uint32_t rsq_segid = num_segments - 1;
if( (options&kIOPKEAcceleratorComputeRsquareMask) == 0 ) { //Compute rsquare.
if(!(options&kIOPKEAcceleratorPreProcessingDone)) { //R0 was not cacluated. should only happen in iBoot.
if(!rsquare){
//should not happen. The expectation is that memory for rsquare should be allocated.
return false;
}
rsa_cal_R0((uint32_t*)modulus, modulus_length, (uint32_t*)rsquare);
}
//Compute R^2
if(!rsa_cal_R2modM(registers, memory, segment_size, (uint32_t*)modulus, modulus_length, (uint32_t*)rsquare, &rsq_segid))
return false;
*rsquare_length = modulus_length;
}
else { //This would have been done while calculating R^2.
//Set the key length;
registers->pke_key_len = config_pke_key_len(modulus_length*DATA_BYTE_TO_BIT);
//Set segment size;
registers->pke_seg_size = PkeSetMode(segment_size);
/* Reset the signbits */
registers->pke_seg_sign = 0;
registers->pke_seg_id = 0;
//Load modulus into seg0;
copy_into_segment(memory, mod_segid, segment_size, modulus, modulus_length);
//copy the rsquare into the hardware segment.
memcpy((uint8_t*)memory+(rsq_segid*segment_size), rsquare, modulus_length);
}
/* Compute (base * r^2 mod M) using hardware */
//Copy base into tmp_segid.
copy_into_segment(memory, tmp_segid, segment_size, base, base_length);
//Setup the segid pointers.
registers->pke_seg_id = RSAPkeSetInOut(iter_segid, tmp_segid, rsq_segid);
//Kick the hardware with pre load modulus bit set.
if(!RSAPkeRun(registers, (PKE_REGMASK_START_PLDM_ON | PKE_REGMASK_START_EXEC_ON)))
return false;
/* compute (1*R^2modM) using hardware. */
registers->pke_seg_size |= PKE_REGVAL_SEG_SIZE_FUNC_ID_A1; // A*1
//When PKE_REGVAL_SEG_SIZE_FUNC_ID_A1 is set, the hardware ignores the segid_B pointer
registers->pke_seg_id = RSAPkeSetInOut(acum_segid, rsq_segid, rsq_segid);
if(!RSAPkeRun(registers, PKE_REGMASK_START_EXEC_ON))
return false;
// Clear the PKE_REGVAL_SEG_SIZE_FUNC_ID_A1 bit.
registers->pke_seg_size &= ~PKE_REGVAL_SEG_SIZE_FUNC_ID_A1;
/* Run the PKE */
uint32_t *exp_word = (uint32_t*)expn;
/* word aligned byte length */
uint32_t uExpLen = ((expn_length + (DATA_WORD_TO_BYTE - 1)) & (~0x3));
uint32_t last_word = exp_word[(uExpLen/DATA_WORD_TO_BYTE) - 1];
uint32_t uIndex = (DATA_WORD_TO_BYTE*DATA_BYTE_TO_BIT) - (highestSetBit(&last_word, DATA_WORD_TO_BYTE) + 1);
for (; uIndex < (uExpLen * DATA_BYTE_TO_BIT); uIndex++) {
unsigned int word;
unsigned int bit;
uint32_t offset = (uExpLen / DATA_WORD_TO_BYTE) - (uIndex / (DATA_WORD_TO_BYTE * DATA_BYTE_TO_BIT)) - 1;
word = exp_word[offset];
registers->pke_seg_id = RSAPkeSetInOut(tmp_segid, acum_segid, acum_segid);
if(!RSAPkeRun(registers, PKE_REGMASK_START_EXEC_ON))
return false;
bit = word & (0x80000000 >> (uIndex % (DATA_WORD_TO_BYTE * DATA_BYTE_TO_BIT)));
if (bit) {
//debug("bit %d set", uIndex);
registers->pke_seg_id = RSAPkeSetInOut(acum_segid, tmp_segid, iter_segid);
if(!RSAPkeRun(registers, PKE_REGMASK_START_EXEC_ON))
return false;
} else {
memcpy( (uint8_t *) memory + acum_segid * segment_size,
(uint8_t *) memory + tmp_segid * segment_size,
segment_size);
if (registers->pke_seg_sign & (0x01 << tmp_segid))
registers->pke_seg_sign |= (0x01 << acum_segid);
else
registers->pke_seg_sign &= ~(0x01 << acum_segid);
}
}
/* Factor out R^-1 from the result */
registers->pke_seg_size |= PKE_REGVAL_SEG_SIZE_FUNC_ID_A1; // A*1
registers->pke_seg_id = RSAPkeSetInOut(tmp_segid, acum_segid, acum_segid);
if (!RSAPkeRun(registers, PKE_REGMASK_START_EXEC_ON))
return false;
registers->pke_seg_size &= ~PKE_REGVAL_SEG_SIZE_FUNC_ID_A1; // A*B
// Check the sign value of tmp_segid and add modulus if negative.
uint32_t uRead, uMask;
uMask = (1 << tmp_segid);
uRead = registers->pke_seg_sign & uMask;
//If negative then add modulus.
if(uRead) {
registers->pke_seg_sign &= ~uMask; //clear the sign.
add( (uint32_t*)(memory+(tmp_segid*segment_size)), (uint32_t*)modulus, modulus_length);
}
/* Copy data out */
memcpy(dst, (uint8_t*)memory+(tmp_segid*segment_size), modulus_length);
*len = modulus_length;
return true;
}
#if IN_KERNEL
bool internalTest(volatile struct pke_regs *registers, volatile uint8_t *memory, uint32_t mod_size, uint64_t *time_micro)
{
uint8_t buff[mod_size];
uint32_t segment_size;
if (mod_size <= (PKE_SEG_SIZE_64)) {
segment_size = PKE_SEG_SIZE_64;
} else if (mod_size <= (PKE_SEG_SIZE_128)) {
segment_size = PKE_SEG_SIZE_128;
} else if (mod_size <= (PKE_SEG_SIZE_256)) {
segment_size = PKE_SEG_SIZE_256;
} else
return false; /* key too long */
uint32_t rsq_segid;
switch (segment_size) {
case PKE_SEG_SIZE_256:
rsq_segid = PKE_SEG_ID_06;
break;
case PKE_SEG_SIZE_128:
rsq_segid = PKE_SEG_ID_14;
break;
case PKE_SEG_SIZE_64:
rsq_segid = PKE_SEG_ID_29;
break;
default:
//Should not happen.
return false;
}
registers->pke_key_len = config_pke_key_len(mod_size*DATA_BYTE_TO_BIT);
//Set segment size;
registers->pke_seg_size = PkeSetMode(segment_size);
/* Reset the signbits */
registers->pke_seg_sign = 0;
registers->pke_seg_id = 0;
debug("key: %x, reg_key: %x, modsize:%u, reg_segsize: %u", config_pke_key_len(mod_size*DATA_BYTE_TO_BIT), registers->pke_key_len, mod_size, registers->pke_seg_size);
//Load modulus into seg0;
memset(buff, 0xF0, mod_size);
copy_into_segment(memory, mod_segid, segment_size, buff, mod_size);
//Set R^2
memset(buff, 0xE5, mod_size);
copy_into_segment(memory, rsq_segid, segment_size, buff, mod_size);
//Set A
memset(buff, 0xD2, mod_size);
copy_into_segment(memory, iter_segid, segment_size, buff, mod_size);
//Setup the segid pointers.
registers->pke_seg_id = RSAPkeSetInOut(iter_segid, tmp_segid, tmp_segid);
uint64_t tasm0, tasm1, tasm2, asm_ns;
tasm0 = mach_absolute_time();
tasm1 = mach_absolute_time();
//Kick the hardware with pre load modulus bit set.
if(!RSAPkeRun(registers, (PKE_REGMASK_START_PLDM_ON | PKE_REGMASK_START_EXEC_ON)))
return false;
tasm2 = mach_absolute_time();
absolutetime_to_nanoseconds( (tasm2 + tasm0 - tasm1 - tasm1), &asm_ns);
//debug("Single multiply time: %lluns\n", asm_ns);
*time_micro = (asm_ns/1000) - 5;
//clear the hardware.
registers->pke_key_len = 0;
registers->pke_seg_size = 0;
registers->pke_seg_sign = 0;
registers->pke_seg_id = 0;
bzero((uint8_t*)memory+(tmp_segid*segment_size), mod_size);
bzero((uint8_t*)memory+(mod_segid*segment_size), mod_size);
bzero((uint8_t*)memory+(iter_segid*segment_size), mod_size);
return true;
}
#endif
Reference in New Issue View Git Blame Copy Permalink