static GcManager *Arena_Init(KonohaContext *kctx)
{
GcManager *mng = (GcManager *)do_malloc(sizeof(GcManager));
size_t i = 0;
for(; i < ARENA_COUNT; ++i) {
MSGC(i).arena_table.table = (ObjectPageTable_t *)do_malloc(ArenaTable_InitSize * sizeof(ObjectPageTable_t));
MSGC(i).arena_table.size = 0;
MSGC(i).arena_table.capacity = ArenaTable_InitSize;
}
return mng;
}
static void *Kmalloc(KonohaContext *kctx, size_t s, KTraceInfo *trace)
{
size_t *p = (size_t *)do_malloc(s
#ifdef MEMORY_DEBUG
+ sizeof(size_t)
#endif
);
if(unlikely(p == NULL)) {
KTraceApi(trace, SystemFault|UserFault, "malloc",
LogUint("size", s), LogUint("UsedMemorySize", klib_malloced));
THROW_OutOfMemory(kctx, s);
}
#if GCDEBUG
OLDTRACE_SWITCH_TO_KTrace(LOGPOL_DEBUG,
LogText("@", "malloc"),
KeyValue_p("from", p),
KeyValue_p("to", ((char *)p)+s),
LogUint("size", s));
#endif
klib_malloced += s;
#ifdef MEMORY_DEBUG
p[0] = s;
p += 1;
#endif
return (void *)p;
}
// This function shall allocate a __cxa_dependent_exception and
// return a pointer to it. (Really to the object, not past its' end).
// Otherwise, it will work like __cxa_allocate_exception.
void * __cxa_allocate_dependent_exception () {
size_t actual_size = sizeof(__cxa_dependent_exception);
void *ptr = do_malloc(actual_size);
if (NULL == ptr)
std::terminate();
std::memset(ptr, 0, actual_size);
return ptr;
}
// Allocate a __cxa_exception object, and zero-fill it.
// Reserve "thrown_size" bytes on the end for the user's exception
// object. Zero-fill the object. If memory can't be allocated, call
// std::terminate. Return a pointer to the memory to be used for the
// user's exception object.
void * __cxa_allocate_exception (size_t thrown_size) throw() {
size_t actual_size = cxa_exception_size_from_exception_thrown_size(thrown_size);
__cxa_exception* exception_header = static_cast<__cxa_exception*>(do_malloc(actual_size));
if (NULL == exception_header)
std::terminate();
std::memset(exception_header, 0, actual_size);
return thrown_object_from_cxa_exception(exception_header);
}
static void *
do_calloc (size_t nmemb, size_t size)
{
int total = nmemb * size;
void *result = do_malloc (total, 2);
if (result)
memset (result, 0, total);
return result;
}
static MarkStack *mstack_Init(MarkStack *mstack)
{
if(mstack->capacity == 0) {
mstack->capacity_log2 = 12;
mstack->capacity = (1 << mstack->capacity_log2) - 1;
DBG_ASSERT(K_PAGESIZE == 1 << 12);
mstack->stack = (kObject**)do_malloc(sizeof(kObject *)*(mstack->capacity + 1));
}
mstack->tail = 0;
return mstack;
}
static void
format_superblock(State *s, SystemFileDiskRecord *rec,
SystemFileDiskRecord *root_rec, SystemFileDiskRecord *sys_rec)
{
struct cmfs_dinode *di;
uint64_t super_off = rec->fe_off;
di = do_malloc(s, s->blocksize);
memset(di, 0, s->blocksize);
strcpy((char *)di->i_signature, CMFS_SUPER_BLOCK_SIGNATURE);
di->i_generation = s->vol_generation;
di->i_fs_generation = s->vol_generation;
di->i_atime = 0;
di->i_ctime = s->format_time;
di->i_mtime = s->format_time;
di->i_blkno = super_off >> s->blocksize_bits;
di->i_flags = CMFS_VALID_FL | CMFS_SYSTEM_FL | CMFS_SUPER_BLOCK_FL;
di->i_clusters = s->volume_size_in_clusters;
di->id2.i_super.s_major_rev_level = CMFS_MAJOR_REV_LEVEL;
di->id2.i_super.s_minor_rev_level = CMFS_MINOR_REV_LEVEL;
di->id2.i_super.s_root_blkno = root_rec->fe_off >> s->blocksize_bits;
di->id2.i_super.s_system_dir_blkno = sys_rec->fe_off >> s->blocksize_bits;
di->id2.i_super.s_mnt_count = 0;
di->id2.i_super.s_max_mnt_count = CMFS_DFL_MAX_MNT_COUNT;
di->id2.i_super.s_state = 0;
di->id2.i_super.s_errors = 0;
di->id2.i_super.s_lastcheck = s->format_time;
di->id2.i_super.s_checkinterval = CMFS_DFL_CHECKINTERVAL;
di->id2.i_super.s_creator_os = CMFS_OS_LINUX;
di->id2.i_super.s_blocksize_bits = s->blocksize_bits;
di->id2.i_super.s_clustersize_bits = s->cluster_size_bits;
/* We clear the "backup_sb" here since it should be written by
* format_backup_super(), not by us. And we have already set the
* "s->no_backup_super" according to the features in get_state(),
* so it's safe to clear the flag here.
*/
s->feature_flags.opt_compat &= ~CMFS_FEATURE_COMPAT_BACKUP_SB;
di->id2.i_super.s_feature_incompat = s->feature_flags.opt_incompat;
di->id2.i_super.s_feature_compat = s->feature_flags.opt_compat;
di->id2.i_super.s_feature_ro_compat = s->feature_flags.opt_ro_compat;
strcpy((char *)di->id2.i_super.s_label, s->vol_label);
memcpy(di->id2.i_super.s_uuid, s->uuid, CMFS_VOL_UUID_LEN);
mkfs_swap_inode_from_cpu(s, di);
mkfs_compute_meta_ecc(s, di, &di->i_check);
do_pwrite(s, di, s->blocksize, super_off);
free(di);
}
void level4(int t)
{
if (t == Malloc)
do_malloc();
else if (t == Div0)
do_div0();
else if (t == Assert)
do_assert();
else
do_crash();
}
/* If src is NULL, we write cleaned buf out. */
static void
write_metadata(State *s, SystemFileDiskRecord *rec, void *src)
{
void *buf;
buf = do_malloc(s, rec->extent_len);
if (!buf) {
fprintf(stderr, "%s:%d: do_malloc failed.",
__func__, __LINE__);
exit(1);
}
memset(buf, 0, rec->extent_len);
if (src)
memcpy(buf, src, rec->file_size);
do_pwrite(s, buf, rec->extent_len, rec->extent_off);
free(buf);
}
static void format_leading_space(State *s)
{
int num_blocks, size;
struct cmfs_vol_disk_hdr *hdr;
struct cmfs_vol_label *lbl;
void *buf;
char *p;
num_blocks = 2;
size = num_blocks << s->blocksize_bits;
p = buf = do_malloc(s, size);
memset(buf, 0, size);
hdr = (struct cmfs_vol_disk_hdr *)buf;
strcpy((char *)hdr->signature, "this is a cmfs volume");
strcpy((char *)hdr->mount_point, "this is a cmfs volume");
p += 512;
lbl = (struct cmfs_vol_label *)p;
strcpy((char *)lbl->label, "this is a cmfs volume");
do_pwrite(s, buf, size, 0);
free(buf);
}
void *
malloc (size_t size)
{
return do_malloc (size, 1);
}
void *
__libc_malloc (size_t size)
{
return do_malloc (size, 1);
}
static int init_spectral_bin (int chan, Spectral_Bin_Type *sb)
{
double en, emin, emax, sigma;
unsigned int min_line, max_line;
unsigned int num, i;
double sum, last;
float *energies, *cum_strengths, *strengths;
if (Have_Line_List == 0)
{
sb->cum_strengths = NULL;
sb->energies = NULL;
sb->num_energies = 0;
sb->pi_chan = chan;
return 0;
}
en = channel_to_kev (chan);
sigma = compute_ccd_sigma (en);
emin = en - 3 * sigma;
emax = en + 3 * sigma;
if (emin < 0.0) emin = 0.0;
min_line = JDMbinary_search_f (emin, Energy_Line_List, Num_Lines);
max_line = JDMbinary_search_f (emax, Energy_Line_List, Num_Lines);
if (min_line == Num_Lines-1)
{
sb->cum_strengths = NULL;
sb->energies = NULL;
sb->num_energies = 0;
return 0;
}
num = max_line - min_line + 1;
if (NULL == (cum_strengths = (float *) do_malloc (num * sizeof (float))))
return -1;
sb->cum_strengths = cum_strengths;
sb->energies = energies = Energy_Line_List + min_line;
sb->num_energies = num;
strengths = Line_Strengths + min_line;
if (num == 1)
{
cum_strengths[0] = 1;
return 0;
}
sigma *= sqrt(2);
sum = 0.0;
last = JDMerf ((energies[0] - en)/sigma);
for (i = 1; i < num; i++)
{
double next = JDMerf ((energies[i] - en)/sigma);
sum += (next - last) * strengths[i-1];
cum_strengths[i-1] = sum;
last = next;
}
if (sum == 0.0)
{
for (i = 1; i < num; i++)
{
sum += 1.0;
cum_strengths[i-1] = sum;
}
}
num--;
for (i = 0; i < num; i++)
cum_strengths[i] /= sum;
return 0;
}
int
main(int argc, char **argv)
{
struct sysinit_data **sipp;
int c;
int entries;
off_t off;
while ((c = getopt(argc, argv, "k:s:i:o:Rh")) != -1) {
switch (c) {
case 'i':
input_f = optarg;
break;
case 'o':
output_f = optarg;
break;
case 'R':
opt_R = 1;
break;
case 'k':
keyword = optarg;
break;
case 's':
struct_name = optarg;
break;
default:
usage();
}
}
if (input_f == NULL || output_f == NULL ||
struct_name == NULL || keyword == NULL)
usage();
atexit(&cleanup);
cleanup();
input_file = open(input_f, O_RDONLY);
if (input_file < 0)
err(EX_SOFTWARE, "Could not open input file: %s", input_f);
output_file = open(output_f, O_TRUNC | O_CREAT | O_RDWR, 0600);
if (output_file < 0)
err(EX_SOFTWARE, "Could not open output file: %s", output_f);
off = lseek(input_file, 0, SEEK_END);
input_ptr = do_malloc(off);
input_len = off;
if (input_len % (uint32_t)sizeof(struct sysinit_data)) {
errx(EX_SOFTWARE, "Input file size is not divisible by %u",
(unsigned int)sizeof(struct sysinit_data));
}
off = lseek(input_file, 0, SEEK_SET);
if (off < 0)
err(EX_SOFTWARE, "Could not seek to start of input file");
if (read(input_file, input_ptr, input_len) != input_len)
err(EX_SOFTWARE, "Could not read input file");
entries = input_len / (uint32_t)sizeof(struct sysinit_data);
start = do_malloc(sizeof(void *) * entries);
stop = start + entries;
for (c = 0; c != entries; c++)
start[c] = &((struct sysinit_data *)input_ptr)[c];
if (start != stop)
endian32 = (*start)->dw_endian32;
/* switch all fields to host endian order */
for (sipp = start; sipp < stop; sipp++) {
(*sipp)->dw_lsb_value = read32((*sipp)->dw_lsb_value);
(*sipp)->dw_msb_value = read32((*sipp)->dw_msb_value);
(*sipp)->dw_file_line = read32((*sipp)->dw_file_line);
}
if (opt_R == 0) {
/* sort entries, rising numerical order */
qsort(start, entries, sizeof(void *), &compare);
} else {
/* sort entries, falling numerical order */
qsort(start, entries, sizeof(void *), &compare_R);
}
/* safe all strings */
for (sipp = start; sipp < stop; sipp++) {
(*sipp)->b_keyword_name[sizeof((*sipp)->b_keyword_name) - 1] = 0;
(*sipp)->b_global_type[sizeof((*sipp)->b_global_type) - 1] = 0;
(*sipp)->b_global_name[sizeof((*sipp)->b_global_name) - 1] = 0;
(*sipp)->b_file_name[sizeof((*sipp)->b_file_name) - 1] = 0;
(*sipp)->b_debug_info[sizeof((*sipp)->b_debug_info) - 1] = 0;
}
if (strcmp(keyword, "sysinit") == 0)
do_sysinit();
else if (strcmp(keyword, "sysuninit") == 0)
do_sysinit();
else
errx(EX_USAGE, "Unknown keyword '%s'", keyword);
success = 1;
return (0);
}
/*************************************************
* Locking_Allocator's Allocation *
*************************************************/
void* Locking_Allocator::alloc_block(u32bit n)
{
return do_malloc(n, true);
}
/*************************************************
* Malloc_Allocator's Allocation *
*************************************************/
void* Malloc_Allocator::allocate(u32bit n)
{
return do_malloc(n, false);
}
