void __init setup_arch(char **cmdline_p)
{
#ifdef CONFIG_ARC_UBOOT_SUPPORT
/* make sure that uboot passed pointer to cmdline/dtb is valid */
if (uboot_tag && is_kernel((unsigned long)uboot_arg))
panic("Invalid uboot arg\n");
/* See if u-boot passed an external Device Tree blob */
machine_desc = setup_machine_fdt(uboot_arg); /* uboot_tag == 2 */
if (!machine_desc)
#endif
{
/* No, so try the embedded one */
machine_desc = setup_machine_fdt(__dtb_start);
if (!machine_desc)
panic("Embedded DT invalid\n");
/*
* If we are here, it is established that @uboot_arg didn't
* point to DT blob. Instead if u-boot says it is cmdline,
* append to embedded DT cmdline.
* setup_machine_fdt() would have populated @boot_command_line
*/
if (uboot_tag == 1) {
/* Ensure a whitespace between the 2 cmdlines */
strlcat(boot_command_line, " ", COMMAND_LINE_SIZE);
strlcat(boot_command_line, uboot_arg,
COMMAND_LINE_SIZE);
}
}
/* Save unparsed command line copy for /proc/cmdline */
*cmdline_p = boot_command_line;
/* To force early parsing of things like mem=xxx */
parse_early_param();
/* Platform/board specific: e.g. early console registration */
if (machine_desc->init_early)
machine_desc->init_early();
smp_init_cpus();
setup_processor();
setup_arch_memory();
/* copy flat DT out of .init and then unflatten it */
unflatten_and_copy_device_tree();
/* Can be issue if someone passes cmd line arg "ro"
* But that is unlikely so keeping it as it is
*/
root_mountflags &= ~MS_RDONLY;
#if defined(CONFIG_VT) && defined(CONFIG_DUMMY_CONSOLE)
conswitchp = &dummy_con;
#endif
arc_unwind_init();
}
void* malloc(size_t size){
/*if (is_kernel() == 1)
krn_debugLogf("kernel");
else {
sdk_debug_logf("app");
}*/
return _malloc_impl(size, is_kernel());
}
static void set_pte_flags_on_range(const char *p, unsigned long l, enum mg mg)
{
lpae_t pte;
int i;
ASSERT(is_kernel(p) && is_kernel(p + l));
/* Can only guard in page granularity */
ASSERT(!((unsigned long) p & ~PAGE_MASK));
ASSERT(!(l & ~PAGE_MASK));
for ( i = (p - _start) / PAGE_SIZE;
i < (p + l - _start) / PAGE_SIZE;
i++ )
{
pte = xen_xenmap[i];
switch ( mg )
{
case mg_clear:
pte.pt.valid = 0;
break;
case mg_ro:
pte.pt.valid = 1;
pte.pt.pxn = 1;
pte.pt.xn = 1;
pte.pt.ro = 1;
break;
case mg_rw:
pte.pt.valid = 1;
pte.pt.pxn = 1;
pte.pt.xn = 1;
pte.pt.ro = 0;
break;
case mg_rx:
pte.pt.valid = 1;
pte.pt.pxn = 0;
pte.pt.xn = 0;
pte.pt.ro = 1;
break;
}
write_pte(xen_xenmap + i, pte);
}
flush_xen_text_tlb();
}
s32 kernel_index(IOS *ios)
{
int i;
for (i = 0; i < ios->content_count; i++)
{
if (!ios->decrypted_buffer[i] || !ios->buffer_size[i])
return -1;
if (is_kernel(ios->decrypted_buffer[i], ios->buffer_size[i]))
return i;
}
return -1;
}
void processExtractedFile(char *filename, char *folderExtractTo, const char *PAKname) {
char extractedFile[255] = "";
int extracted = 0;
if (is_lz4(filename)) {
constructPath(extractedFile, folderExtractTo, PAKname, ".unlz4");
printf("UnLZ4 %s to %s\n", filename, extractedFile);
extracted = !decode_file(filename, extractedFile);
} else {
if (check_lzo_header(filename)) {
constructPath(extractedFile, folderExtractTo, PAKname, ".unpacked");
printf("LZOunpack %s to %s\n", filename, extractedFile);
extracted = !lzo_unpack((const char*) filename, (const char*) extractedFile);
} else {
if (is_cramfs_image(filename)) {
constructPath(extractedFile, folderExtractTo, PAKname, NULL);
printf("Uncramfs %s to folder %s\n", filename, extractedFile);
rmrf(extractedFile);
uncramfs(extractedFile, filename);
return;
} else {
if (is_kernel(filename)) {
constructPath(extractedFile, folderExtractTo, PAKname, ".unpaked");
printf("Extracting kernel %s to %s\n", filename, extractedFile);
extract_kernel(filename, extractedFile);
extracted = 1;
} else {
if (is_nfsb(filename)) {
constructPath(extractedFile, folderExtractTo, PAKname, ".unnfsb");
printf("Unnfsb %s to %s\n", filename, extractedFile);
unnfsb(filename, extractedFile);
extracted = 1;
}
}
}
}
}
if (strcmp(PAKname, "patc") != 0 && strcmp(PAKname, "extr") != 0) {
if (is_squashfs(filename)) {
constructPath(extractedFile, folderExtractTo, PAKname, NULL);
printf("Unsquashfs %s to folder %s\n", filename, extractedFile);
rmrf(extractedFile);
unsquashfs(filename, extractedFile);
return;
}
} else {
printf("!!!Skipping unsquashfs (%s) as it doesn't know how to handle it...\n", PAKname);
return;
}
if (extracted) processExtractedFile(extractedFile, folderExtractTo, PAKname);
}
/* Boot-time pagetable setup.
* Changes here may need matching changes in head.S */
void __init setup_pagetables(unsigned long boot_phys_offset, paddr_t xen_paddr)
{
unsigned long dest_va;
lpae_t pte, *p;
int i;
/* Map the destination in the boot misc area. */
dest_va = BOOT_MISC_VIRT_START;
pte = mfn_to_xen_entry(xen_paddr >> PAGE_SHIFT);
write_pte(xen_second + second_table_offset(dest_va), pte);
flush_xen_data_tlb_range_va(dest_va, SECOND_SIZE);
/* Calculate virt-to-phys offset for the new location */
phys_offset = xen_paddr - (unsigned long) _start;
/* Copy */
memcpy((void *) dest_va, _start, _end - _start);
/* Beware! Any state we modify between now and the PT switch may be
* discarded when we switch over to the copy. */
/* Update the copy of xen_pgtable to use the new paddrs */
p = (void *) xen_pgtable + dest_va - (unsigned long) _start;
#ifdef CONFIG_ARM_64
p[0].pt.base += (phys_offset - boot_phys_offset) >> PAGE_SHIFT;
p = (void *) xen_first + dest_va - (unsigned long) _start;
#endif
for ( i = 0; i < 4; i++)
p[i].pt.base += (phys_offset - boot_phys_offset) >> PAGE_SHIFT;
p = (void *) xen_second + dest_va - (unsigned long) _start;
if ( boot_phys_offset != 0 )
{
/* Remove the old identity mapping of the boot paddr */
vaddr_t va = (vaddr_t)_start + boot_phys_offset;
p[second_linear_offset(va)].bits = 0;
}
for ( i = 0; i < 4 * LPAE_ENTRIES; i++)
if ( p[i].pt.valid )
p[i].pt.base += (phys_offset - boot_phys_offset) >> PAGE_SHIFT;
/* Change pagetables to the copy in the relocated Xen */
boot_ttbr = (uintptr_t) xen_pgtable + phys_offset;
flush_xen_dcache(boot_ttbr);
flush_xen_dcache_va_range((void*)dest_va, _end - _start);
flush_xen_text_tlb();
WRITE_SYSREG64(boot_ttbr, TTBR0_EL2);
dsb(); /* Ensure visibility of HTTBR update */
flush_xen_text_tlb();
/* Undo the temporary map */
pte.bits = 0;
write_pte(xen_second + second_table_offset(dest_va), pte);
flush_xen_text_tlb();
/* Link in the fixmap pagetable */
pte = mfn_to_xen_entry((((unsigned long) xen_fixmap) + phys_offset)
>> PAGE_SHIFT);
pte.pt.table = 1;
write_pte(xen_second + second_table_offset(FIXMAP_ADDR(0)), pte);
/*
* No flush required here. Individual flushes are done in
* set_fixmap as entries are used.
*/
/* Break up the Xen mapping into 4k pages and protect them separately. */
for ( i = 0; i < LPAE_ENTRIES; i++ )
{
unsigned long mfn = paddr_to_pfn(xen_paddr) + i;
unsigned long va = XEN_VIRT_START + (i << PAGE_SHIFT);
if ( !is_kernel(va) )
break;
pte = mfn_to_xen_entry(mfn);
pte.pt.table = 1; /* 4k mappings always have this bit set */
if ( is_kernel_text(va) || is_kernel_inittext(va) )
{
pte.pt.xn = 0;
pte.pt.ro = 1;
}
if ( is_kernel_rodata(va) )
pte.pt.ro = 1;
write_pte(xen_xenmap + i, pte);
/* No flush required here as page table is not hooked in yet. */
}
pte = mfn_to_xen_entry((((unsigned long) xen_xenmap) + phys_offset)
>> PAGE_SHIFT);
pte.pt.table = 1;
write_pte(xen_second + second_linear_offset(XEN_VIRT_START), pte);
/* TLBFLUSH and ISB would be needed here, but wait until we set WXN */
/* From now on, no mapping may be both writable and executable. */
WRITE_SYSREG32(READ_SYSREG32(SCTLR_EL2) | SCTLR_WXN, SCTLR_EL2);
/* Flush everything after setting WXN bit. */
flush_xen_text_tlb();
}
void* calloc(size_t size){
return _calloc_impl(size, is_kernel());
}
void* realloc(void* oldptr, size_t size){
return _realloc_impl(oldptr, size, is_kernel());
}
void free(void* ptr){
_free_impl(ptr, is_kernel());
}
/**
* Lookup the symbol name corresponding to a kernel address
*/
const char *kallsyms_lookup(unsigned long addr,
unsigned long *symbolsize,
unsigned long *offset,
char *namebuf)
{
unsigned long i, low, high, mid;
/* This kernel should never had been booted. */
BUG_ON(!kallsyms_addresses);
namebuf[KSYM_NAME_LEN] = 0;
namebuf[0] = 0;
if ((all_var && is_kernel(addr)) ||
(!all_var && (is_kernel_text(addr) || is_kernel_inittext(addr) ||
is_kernel_extratext(addr)))) {
unsigned long symbol_end = 0;
/* do a binary search on the sorted kallsyms_addresses array */
low = 0;
high = kallsyms_num_syms;
while (high-low > 1) {
mid = (low + high) / 2;
if (kallsyms_addresses[mid] <= addr) low = mid;
else high = mid;
}
/* search for the first aliased symbol. Aliased symbols are
symbols with the same address */
while (low && kallsyms_addresses[low - 1] ==
kallsyms_addresses[low])
--low;
/* Grab name */
kallsyms_expand_symbol(get_symbol_offset(low), namebuf);
/* Search for next non-aliased symbol */
for (i = low + 1; i < kallsyms_num_syms; i++) {
if (kallsyms_addresses[i] > kallsyms_addresses[low]) {
symbol_end = kallsyms_addresses[i];
break;
}
}
/* if we found no next symbol, we use the end of the section */
if (!symbol_end) {
if (is_kernel_inittext(addr))
symbol_end = (unsigned long)_einittext;
else
symbol_end = (all_var) ? (unsigned long)_end
: (unsigned long)_etext;
}
if (symbolsize)
*symbolsize = symbol_end - kallsyms_addresses[low];
if (offset)
*offset = addr - kallsyms_addresses[low];
return namebuf;
}
return NULL;
}
int handle_file(const char *file, struct config_opts_t *config_opts) {
const char *dest_dir = config_opts->dest_dir;
const char *file_name = basename(strdup(file));
char dest_file[1024] = "";
char lz4pack[1024] = "";
if (check_lzo_header(file)) {
constructPath(dest_file, dest_dir, file_name, ".lzounpack");
printf("Extracting LZO file to: %s\n", dest_file);
if (lzo_unpack(file, dest_file) == 0) {
handle_file(dest_file, config_opts);
return EXIT_SUCCESS;
}
} else if (is_nfsb(file)) {
constructPath(dest_file, dest_dir, file_name, ".unnfsb");
printf("Extracting nfsb image to: %s.\n\n", dest_file);
unnfsb(file, dest_file);
handle_file(dest_file, config_opts);
return EXIT_SUCCESS;
} else if (is_lz4(file)) {
constructPath(dest_file, dest_dir, file_name, ".unlz4");
printf("UnLZ4 file to: %s\n", dest_file);
decode_file(file, dest_file);
return EXIT_SUCCESS;
} else if (is_squashfs(file)) {
constructPath(dest_file, dest_dir, file_name, ".unsquashfs");
printf("Unsquashfs file to: %s\n", dest_file);
rmrf(dest_file);
unsquashfs(file, dest_file);
return EXIT_SUCCESS;
} else if (is_gzip(file)) {
constructPath(dest_file, dest_dir, "", "");
printf("Extracting gzip file %s\n", file_name);
strcpy(dest_file, file_uncompress_origname((char *)file, dest_file));
return EXIT_SUCCESS;
} else if(is_cramfs_image(file, "be")) {
constructPath(dest_file, dest_dir, file_name, ".cramswap");
printf("Swapping cramfs endian for file %s\n",file);
cramswap(file, dest_file);
return EXIT_SUCCESS;
} else if(is_cramfs_image(file, "le")) {
constructPath(dest_file, dest_dir, file_name, ".uncramfs");
printf("Uncramfs %s to folder %s\n", file, dest_file);
rmrf(dest_file);
uncramfs(dest_file, file);
return EXIT_SUCCESS;
} else if (isFileEPK2(file)) {
extractEPK2file(file, config_opts);
return EXIT_SUCCESS;
} else if (isFileEPK1(file)) {
extract_epk1_file(file, config_opts);
return EXIT_SUCCESS;
} else if (is_kernel(file)) {
constructPath(dest_file, dest_dir, file_name, ".unpaked");
printf("Extracting boot image to: %s.\n\n", dest_file);
extract_kernel(file, dest_file);
handle_file(dest_file, config_opts);
return EXIT_SUCCESS;
} else if(isPartPakfile(file)) {
constructPath(dest_file, dest_dir, remove_ext(file_name), ".txt");
printf("Saving Partition info to: %s\n", dest_file);
dump_partinfo(file, dest_file);
return EXIT_SUCCESS;
} else if(is_jffs2(file)) {
constructPath(dest_file, dest_dir, file_name, ".unjffs2");
printf("jffs2extract %s to folder %s\n", file, dest_file);
rmrf(dest_file);
jffs2extract(file, dest_file, "1234");
return EXIT_SUCCESS;
} else if(isSTRfile(file)) {
constructPath(dest_file, dest_dir, file_name, ".ts");
setKey();
printf("\nConverting %s file to TS: %s\n", file, dest_file);
convertSTR2TS(file, dest_file, 0);
return EXIT_SUCCESS;
} else if(!memcmp(&file[strlen(file)-3], "PIF", 3)) {
constructPath(dest_file, dest_dir, file_name, ".ts");
setKey();
printf("\nProcessing PIF file: %s\n", file);
processPIF(file, dest_file);
return EXIT_SUCCESS;
} else if(symfile_load(file) == 0) {
constructPath(dest_file, dest_dir, file_name, ".idc");
printf("Converting SYM file to IDC script: %s\n", dest_file);
symfile_write_idc(dest_file);
return EXIT_SUCCESS;
}
return EXIT_FAILURE;
}
int handle_file(const char *file, struct config_opts_t *config_opts) {
const char *dest_dir = config_opts->dest_dir;
const char *file_name = basename(strdup(file));
char dest_file[1024] = "";
char lz4pack[1024] = "";
if (check_lzo_header(file)) {
constructPath(dest_file, dest_dir, file_name, ".lzounpack");
printf("Extracting LZO file to: %s\n", dest_file);
if (lzo_unpack(file, dest_file) == 0) {
handle_file(dest_file, config_opts);
return EXIT_SUCCESS;
}
} else if (is_nfsb(file)) {
constructPath(dest_file, dest_dir, file_name, ".unnfsb");
printf("Extracting nfsb image to: %s.\n\n", dest_file);
unnfsb(file, dest_file);
handle_file(dest_file, config_opts);
return EXIT_SUCCESS;
} else if (is_lz4(file)) {
constructPath(dest_file, dest_dir, file_name, ".unlz4");
printf("UnLZ4 file to: %s\n", dest_file);
decode_file(file, dest_file);
return EXIT_SUCCESS;
} else if (is_squashfs(file)) {
constructPath(dest_file, dest_dir, file_name, ".unsquashfs");
printf("Unsquashfs file to: %s\n", dest_file);
rmrf(dest_file);
unsquashfs(file, dest_file);
return EXIT_SUCCESS;
} else if (is_cramfs_image(file)) {
constructPath(dest_file, dest_dir, file_name, ".uncramfs");
printf("Uncramfs file to: %s\n", dest_file);
rmrf(dest_file);
uncramfs(dest_file, file);
return EXIT_SUCCESS;
} else if (isFileEPK2(file)) {
extractEPK2file(file, config_opts);
return EXIT_SUCCESS;
} else if (isFileEPK1(file)) {
extract_epk1_file(file, config_opts);
return EXIT_SUCCESS;
} else if (is_kernel(file)) {
constructPath(dest_file, dest_dir, file_name, ".unpaked");
printf("Extracting boot image to: %s.\n\n", dest_file);
extract_kernel(file, dest_file);
handle_file(dest_file, config_opts);
return EXIT_SUCCESS;
} else if(isSTRfile(file)) {
constructPath(dest_file, dest_dir, file_name, ".ts");
setKey();
printf("\nConverting %s file to TS: %s\n", file, dest_file);
convertSTR2TS(file, dest_file, 0);
return EXIT_SUCCESS;
} else if(!memcmp(&file[strlen(file)-3], "PIF", 3)) {
constructPath(dest_file, dest_dir, file_name, ".ts");
setKey();
printf("\nProcessing PIF file: %s\n", file);
processPIF(file, dest_file);
return EXIT_SUCCESS;
} else if(symfile_load(file) == 0) {
constructPath(dest_file, dest_dir, file_name, ".idc");
printf("Converting SYM file to IDC script: %s\n", dest_file);
symfile_write_idc(dest_file);
return EXIT_SUCCESS;
}
return EXIT_FAILURE;
}
