示例#1
1
文件: memtest.c 项目: Happykat/ATOS
unsigned int memtest(multiboot_info_t* mbd, unsigned int magic)
{

	magic = (int) magic;

	terminal_writestring(MULTIBOOT_TEST);

	if (CHECK_BIT(mbd->flags, 0))
	{
		vgatestok();
		terminal_writestring(MEMORY_MAP_TEST);
		
		if (CHECK_BIT(mbd->flags, 6))
		{
			vgatestok();
			terminal_printf("\nLower memory : %d KB\n", mbd->mem_lower);
			terminal_printf("Upper memory : %d KB\n\n", mbd->mem_upper);
		}

		else
		{
			vgatestko();
			return (1);
		}

		return (0);
	}

	vgatestko();
	return (1);
}
示例#2
0
文件: loader.c 项目: mogaika/torchos
uint64_t load_kernel(uint8_t *pack_start, uint8_t *pack_end) {
	terminal_printf("Packed kernel start: 0x%p; size: %u\n",
		pack_start, pack_end - pack_start);

	Elf64_Ehdr_t *ehdr = (Elf64_Ehdr_t*) pack_start;
	terminal_printf("entry: 0x%l; phoff: 0x%l\n", ehdr->e_entry, ehdr->e_phoff);
	
	Elf64_Phdr_t *phdr = (Elf64_Phdr_t*) (pack_start + ehdr->e_phoff);
	for (int i = 0; i < ehdr->e_phnum; i++, phdr++) {
		if (phdr->p_type != ELF64_PT_LOAD)
			continue;

		terminal_printf("+ section [%c%c%c]:0x%l[0x%l] va:0x%l[0x%l]\n", (phdr->p_flags & ELF64_PF_X) ? 'X' : '-',
			(phdr->p_flags & ELF64_PF_W) ? 'W' : '-', (phdr->p_flags & ELF64_PF_R) ? 'R' : '-',
			phdr->p_offset, phdr->p_filesz, phdr->p_vaddr, phdr->p_memsz);	
		
		for (uint64_t ppos = 0; ppos < phdr->p_memsz; ppos += PAGE_SIZE) {
			uint64_t vaddr = phdr->p_vaddr + ppos;
			terminal_printf(" trying to alloc and map %l\n", vaddr);
			
			uint32_t pp = phys_alloc_to_virt4k(vaddr, !!(phdr->p_flags & ELF64_PF_W), !!(phdr->p_flags & ELF64_PF_X));
			if (ppos < phdr->p_memsz) {
				uint32_t csize = (phdr->p_memsz - ppos) > PAGE_SIZE ? PAGE_SIZE : (phdr->p_memsz - ppos);
				memcpy((void*) pp, (void*)(pack_start + phdr->p_offset + ppos), csize);
			}
		}
	}

	return ehdr->e_entry;
}
示例#3
0
文件: kernel.c 项目: candraw/fOS
void greet() {
    const char* str = "Hallo Welt!";
    hexdump(str, strlen(str));

    terminal_printf("kernel end: %x\n", (int)end);

    char *page = kalloc();
    terminal_printf("allocated page: %x\n", page);
    page = kalloc();
    terminal_printf("allocated page: %x\n", page);
}
示例#4
0
文件: loader.c 项目: mogaika/torchos
bool process_multiboot(uint32_t uMagic, multiboot_info_t *pMultiboot,
	uint32_t *total_memory, multiboot_memory_map_t **multiboot_mmap, uint32_t *mmap_lenght) {
	bool magic_match = uMagic == MULTIBOOT_BOOTLOADER_MAGIC;
	print_requirement("Multiboot magic match", magic_match);
	if (!magic_match) {
		terminal_printf("Multiboot magic not correct 0x%p != 0x%p\n",
			uMagic, MULTIBOOT_BOOTLOADER_MAGIC);
		return false;
	}
	
	bool have_meminfo = pMultiboot->flags & MULTIBOOT_INFO_MEMORY;
	bool have_memmap = pMultiboot->flags & MULTIBOOT_INFO_MEM_MAP;

	print_requirement("Multiboot memory info", have_meminfo);
	print_requirement("Multiboot memory map", have_memmap);

	terminal_printf("Multiboot struct: 0x%p; magic: 0x%p\n", pMultiboot, uMagic);

	if (magic_match) {
		terminal_printf("Multiboot magic correct. Flags: b%b\n", pMultiboot->flags);
	}

	if (have_meminfo) {
		uint32_t memtotal = pMultiboot->mem_upper ? (pMultiboot->mem_upper + 1024) : pMultiboot->mem_lower;
		*total_memory = memtotal;
		terminal_printf("mem_lower = %uKB, mem_upper = %uKB (%uMb), total: %uMb(%ukB)\n",
			pMultiboot->mem_lower, pMultiboot->mem_upper, pMultiboot->mem_upper / 1024,
			memtotal / 1024, memtotal);
	} else
		return false;

	if (have_memmap) {
		multiboot_memory_map_t *mmap = (multiboot_memory_map_t*)pMultiboot->mmap_addr;
		uint32_t mmapEnd = pMultiboot->mmap_addr + pMultiboot->mmap_length;

		*multiboot_mmap = mmap;
		*mmap_lenght = pMultiboot->mmap_length;

		terminal_printf ("Multiboot mmap_addr: 0x%p, mmap_length: 0x%x\nMemmap:\n",
			pMultiboot->mmap_addr, pMultiboot->mmap_length);

		while((uint32_t)mmap < mmapEnd) {
			terminal_printf(" (0x%p[%u]) addr: 0x%l (%x:%x), len: 0x%l (%x:%x), type: 0x%x\n",
				mmap, mmap->size, mmap->addr, (uint32_t)(mmap->addr >> 32), (uint32_t) mmap->addr,
				mmap->len, (uint32_t)(mmap->len >> 32), (uint32_t) mmap->len, mmap->type);

			mmap = (multiboot_memory_map_t*)((uint32_t)mmap + mmap->size + sizeof(mmap->size));
		}
	}

	return true;
}
示例#5
0
文件: loader.c 项目: mogaika/torchos
bool init_screen() {
	terminal_initialize();

	terminal_setcolor(make_color(FGCOLOR, BGCOLOR));
	terminal_clear();

	terminal_printf("Welcome to ");
	terminal_setcolor(make_color(COLOR_MAGENTA, BGCOLOR));
	terminal_printf("%s", __KERNEL_NAME);

	terminal_setcolor(make_color(FGCOLOR, BGCOLOR));
	terminal_printf(" multiboot32 => kernel loader\n");
	return true;
}
示例#6
0
int cmd_logout(int argc, char **argv)
{
	static struct option long_options[] = {
		{"force", no_argument, NULL, 'f'},
		{0, 0, 0, 0}
	};
	int option;
	int option_index;
	bool force = false;
	struct session *session = NULL;
	unsigned char key[KDF_HASH_LEN];

	while ((option = getopt_long(argc, argv, "f", long_options, &option_index)) != -1) {
		switch (option) {
			case 'f':
				force = true;
				break;
			case '?':
			default:
				die_usage(cmd_logout_usage);
		}
	}
	if (optind < argc)
		die_usage(cmd_logout_usage);

	if (!config_exists("verify"))
		die("Not currently logged in.");

	if (!force && !ask_yes_no(true, "Are you sure you would like to log out?")) {
		terminal_printf(TERMINAL_FG_YELLOW TERMINAL_BOLD "Log out" TERMINAL_RESET ": aborted.\n");
		return 1;
	}

	init_all(0, key, &session, NULL);

	if (!config_unlink("verify") || !config_unlink("username") || !config_unlink("session_sessionid") || !config_unlink("iterations"))
		die_errno("could not log out.");
	config_unlink("blob");
	config_unlink("session_token");
	config_unlink("session_uid");
	config_unlink("session_privatekey");
	config_unlink("plaintext_key");
	agent_kill();
	upload_queue_kill();
	lastpass_logout(session);
	terminal_printf(TERMINAL_FG_YELLOW TERMINAL_BOLD "Log out" TERMINAL_RESET ": complete.\n");
	return 0;
}
示例#7
0
文件: kernel.c 项目: candraw/fOS
void init_kernel() 
{
    terminal_initialize();

    init_serial(COM1);
    terminal_enable_serial_echo(COM1);

    terminal_printf("fOS version %s\n\n\n", KERNEL_VERSION);

    kinit(end + 4096, end + 4096 + (100 * 4096));

    init_gdt();
    load_gdt();


    load_idt();
    load_isrs();

    irq_install();
    asm volatile ( "sti" );

    timer_install();
    sleep(1);

    keyboard_install();

    init_paging();
    switch_to_paging();
}
示例#8
0
void Alo_Main(multiboot_data *multibootdata) { 
	HAL_init(multibootdata);  
	terminal_putstring("Hello to Alo 2!\n"); 
	terminal_putstring(" Just testing newlines....\n"); 
	terminal_printf("-13 when put through itoa is: %d.", -13); 
	terminal_printf("My name is %s.", "Alex"); 
	terminal_printf("Today is %s %d, %d. It is a %s. It is %d:%d:%d military time.", GetMonth(), GetDayInMonth(), GetYear(), GetWeekDay(), GetHour(), GetMinute(), GetSecond()); 
	/*testtimer.limit = 100; 
	testtimer.func = OneSecondHandler; 
	secondtimer.limit = 200; 
	secondtimer.func = TheResponse; 
	Timer_Register_Timer(&testtimer); 
	Timer_Register_Timer(&secondtimer); */ 
	/* int test = 8/(6 - (3 * 2)); */ 
	
}; 
示例#9
0
文件: monitor.c 项目: spectrec/ann
void monitor_process_key_press(uint8_t scancode)
{
	struct terminal_position p = terminal_position();
	uint8_t code = scancodes[scancode];
	const char *command = NULL;

	terminal_set_position(command_line_position);
	if (scancode == KEY_BACKSPACE &&
	    command_line_position.column > COMMAND_LINE_PROMPT_LEN) {
		command_line_position.column--;
		terminal_set_position(command_line_position);
		terminal_put(' ');
	} else if (code == '\n') {
		command = terminal_read_command(COMMAND_LINE_PROMPT_LEN);
		assert(command != NULL);

		terminal_clear_line();
	} else if (code != 0) {
		if (command_line_position.column < TERMINAL_COL_COUNT-1) {
			command_line_position.column++;
			terminal_put(code);
		}
	}

	if (command != NULL) {
		// redraw command line prompt
		terminal_printf("%s", COMMAND_LINE_PROMPT);
		command_line_position = terminal_position();
	}

	terminal_set_position(p);
	if (command != NULL)
		monitor_process_command(command);
}
示例#10
0
static void help(void)
{
	terminal_printf("Usage:\n");
	printf("  %s {--help|--version}\n", ARGV[0]);
	for (size_t i = 0; i < ARRAY_SIZE(commands); ++i)
		printf("  %s %s\n", ARGV[0], commands[i].usage);
}
示例#11
0
文件: kernel.c 项目: luk2010/APrOS
void kernel_main()
{
	terminal_cls(COLOR_LIGHT_BLUE);
	terminal_setcolor(make_color(COLOR_WHITE, COLOR_LIGHT_BLUE));
	/* Since there is no support for newlines in terminal_putchar yet, \n will
	   produce some VGA specific character instead. This is normal. */
	terminal_writestring("Hello, kernel World!\n");

	terminal_printf("This is the base string terminal system !\n");

	if(apros_setup_gdt() > 0)
		terminal_printf("GDT correctly setted !\n");
	if(apros_setup_idt())
		terminal_printf("IDT correctly setted ! \n");

	for(;;)
		continue;
}
示例#12
0
文件: map.c 项目: spectrec/ann
void page_decref(struct page *p)
{
	assert(p->ref > 0);
	p->ref--;

	terminal_printf("decref page %p, refs: %d\n", p, p->ref);

	if (p->ref == 0)
		page_free(p);
}
示例#13
0
int cmd_status(int argc, char **argv)
{
	unsigned char key[KDF_HASH_LEN];
	static struct option long_options[] = {
		{"quiet", no_argument, NULL, 'q'},
		{"color", required_argument, NULL, 'C'},
		{0, 0, 0, 0}
	};
	int option;
	int option_index;
	bool quiet = false;
	_cleanup_free_ char *username = NULL;

	while ((option = getopt_long(argc, argv, "q", long_options, &option_index)) != -1) {
		switch (option) {
			case 'q':
				quiet = true;
				break;
			case 'C':
				terminal_set_color_mode(
					parse_color_mode_string(optarg));
				break;
			case '?':
			default:
				die_usage(cmd_status_usage);
		}
	}

	if (!agent_ask(key)) {
		if(!quiet) {
			terminal_printf(TERMINAL_FG_RED TERMINAL_BOLD "Not logged in" TERMINAL_RESET ".\n");
		}
		return 1;
	} else {
		if(!quiet) {
			username = config_read_string("username");
			terminal_printf(TERMINAL_FG_GREEN TERMINAL_BOLD "Logged in" TERMINAL_RESET " as " TERMINAL_UNDERLINE "%s" TERMINAL_RESET ".\n", username);
		}
		return 0;
	}
}
示例#14
0
文件: monitor.c 项目: spectrec/ann
void monitor_init(void)
{
	command_line_position.row = TERMINAL_ROW_COUNT;
	command_line_position.column = 0;

	struct terminal_position p = terminal_position();
	terminal_set_position(command_line_position);

	terminal_printf("%s", COMMAND_LINE_PROMPT);
	command_line_position = terminal_position();

	terminal_set_position(p);
}
示例#15
0
void fault_handler(struct idt_info* ptr)
{
	if (ptr->code < 32)
	{
		die("fault_handler:%s, code=%d, error=%d\n",
				exception_messages[ptr->code],
				ptr->code, ptr->error);
	}

	switch (ptr->code)
	{
		default:
			{
				terminal_printf("defualt isr handler:code=%d, error=%d\n",
						ptr->code, ptr->error);
			}
	}
}
示例#16
0
文件: loader.c 项目: mogaika/torchos
void print_requirement(const char *text, bool have) {
	terminal_setcolor(make_color(FGCOLOR, BGCOLOR));
	terminal_printf(" - %s ", text);

	size_t textlen = strlen(text);
	for (size_t pneed = textlen; pneed < 32; pneed++) {
		terminal_putchar('.');
	}

	terminal_putchar('[');
	if (have) {
		terminal_setcolor(make_color(COLOR_GREEN, BGCOLOR));
		terminal_writestring("OK");
	} else {
		terminal_setcolor(make_color(COLOR_RED, BGCOLOR));
		terminal_writestring("FAIL");
	}
	terminal_setcolor(make_color(FGCOLOR, BGCOLOR));
	terminal_writestring("]\n");
}
示例#17
0
文件: loader.c 项目: mogaika/torchos
bool process_cpu_features() {
	uint32_t cpuidmax = __get_cpuid_max(0, 0);
	bool have_cpuid = cpuidmax != 0;

	print_requirement("CPUID instruction", have_cpuid);
	if (!have_cpuid)
		return false;

	uint32_t a, b, c, d;
	uint32_t cpuidext = __get_cpuid(0x80000001, &a, &b, &c, &d);
	bool have_ext_cpuid = cpuidext != 0;
	print_requirement("CPUID 0x80000001", have_ext_cpuid);
	if (!have_ext_cpuid)
		return false;

	bool have_64bit = d & (1 << 29);
	print_requirement("64 bit longmode support", have_64bit);
	terminal_printf("cpuid[0x80000001] edx:%p ecx:%p\n", d, c);

	return have_64bit;
}
void AnimateDamage(int x, int y, int damage)
{
	std::ostringstream ss;
	ss << damage;
	std::string s = ss.str();

	int n_steps = duration * fps;
	float angle_delta = 2.0f * pi / n_steps;

	terminal_layer(animation_layer);
	for (int i=0; i<n_steps; i++)
	{
		if (terminal_has_input()) break;
		terminal_clear_area(0, 0, terminal_state(TK_WIDTH), terminal_state(TK_HEIGHT));
		float dx = std::sin(i*angle_delta) * radius * terminal_state(TK_CELL_WIDTH) + i*2;
		float dy = -2.0f * radius * terminal_state(TK_CELL_WIDTH) / n_steps * i - terminal_state(TK_CELL_HEIGHT)/2;
		terminal_color(color_from_argb(255/n_steps*(n_steps-i), 255, 64, 0));
		terminal_printf(x, y, "[offset=%dx%d]%s", (int)dx, (int)dy, s.c_str());
		terminal_refresh();
		terminal_delay(1000/fps);
	}
	terminal_color("white");
}
示例#19
0
int cmd_login(int argc, char **argv)
{
    static struct option long_options[] = {
        {"trust", no_argument, NULL, 't'},
        {"plaintext-key", no_argument, NULL, 'P'},
        {"force", no_argument, NULL, 'f'},
        {"color", required_argument, NULL, 'C'},
        {0, 0, 0, 0}
    };
    int option;
    int option_index;
    bool trust = false;
    bool plaintext_key = false;
    bool force = false;
    char *username;
    _cleanup_free_ char *error = NULL;
    _cleanup_free_ char *password = NULL;
    int iterations;
    struct session *session;
    unsigned char key[KDF_HASH_LEN];
    char hex[KDF_HEX_LEN];

    while ((option = getopt_long(argc, argv, "f", long_options, &option_index)) != -1) {
        switch (option) {
        case 't':
            trust = true;
            break;
        case 'P':
            plaintext_key = true;
            break;
        case 'f':
            force = true;
            break;
        case 'C':
            terminal_set_color_mode(
                parse_color_mode_string(optarg));
            break;
        case '?':
        default:
            die_usage(cmd_login_usage);
        }
    }
    if (argc - optind != 1)
        die_usage(cmd_login_usage);

    if (!force && plaintext_key && !ask_yes_no(false, "You have used the --plaintext-key option. This option will greatly reduce the security of your passwords. You are advised, instead, to use the agent, whose timeout can be disabled by settting LPASS_AGENT_TIMEOUT=0. Are you sure you would like to do this?"))
        die("Login aborted. Try again without --plaintext-key.");

    username = argv[optind];
    iterations = lastpass_iterations(username);
    if (!iterations)
        die("Unable to fetch iteration count. Check your internet connection and be sure your username is valid.");

    do {
        free(password);
        password = password_prompt("Master Password", error, "Please enter the LastPass master password for <%s>.", username);
        if (!password)
            die("Failed to enter correct password.");

        kdf_login_key(username, password, iterations, hex);
        kdf_decryption_key(username, password, iterations, key);

        free(error);
        error = NULL;
        session = lastpass_login(username, hex, key, iterations, &error, trust);
    } while (!session_is_valid(session));

    config_unlink("plaintext_key");
    if (plaintext_key)
        config_write_buffer("plaintext_key", (char *)key, KDF_HASH_LEN);

    agent_save(username, iterations, key);

    session_save(session, key);
    session_free(session);
    session = NULL;

    terminal_printf(TERMINAL_FG_GREEN TERMINAL_BOLD "Success" TERMINAL_RESET ": Logged in as " TERMINAL_UNDERLINE "%s" TERMINAL_RESET ".\n", username);

    return 0;
}
示例#20
0
void panic(const char* msg) { 
	terminal_printf("KERNEL PANIC: %s.", msg);  
	__asm__  __volatile__("cli"); /* Disable interrupts */ 
	for (;;)    ;  
}; 
示例#21
0
void OneSecondHandler(interrupt_stackstate *lstack) { 
	terminal_printf("About one second has passed."); 
}; 
示例#22
0
void TheResponse(interrupt_stackstate *lstack) { 
	terminal_printf("About two seconds have passed."); 
}; 
示例#23
0
void BasicOutput()
{
	terminal_options("title=BearLibTerminal demo: output facilities");
	terminal_options("font.name=default; font.supplement=Media/Omni/supplement-runic.png");

	terminal_blending(BLENDING_ADDITIVE);
	terminal_color(COLOR_WHITE);

	terminal_clear();

	// Simple output with postformatting
	terminal_printf(1, 1, "[color=gray]1. Most basic:[/color] ABC abc");

	// Wide color range
	int n = terminal_printf(1, 3, "[color=gray]2. Colors: ");
	const char long_word[] = "Antidisestablishmentarianism";
	const size_t long_word_length = sizeof(long_word)-1;
	for ( size_t i = 0; i < long_word_length; i++ )
	{
		float factor = float(i)/long_word_length;
		int red = (1.0f - factor) * 255;
		int green = factor * 255;
		terminal_color(color_from_argb(255, red, green, 0));
		terminal_put(n+1+i, 3, long_word[i]);
	}
	terminal_color(color_from_name("white"));

	// Tile backgrounds
	terminal_printf(1, 5, "[color=gray]3. Backgrounds: [color=black][bkcolor=gray] grey [/bkcolor] [bkcolor=red] red ");

	// Simple unicode output
	terminal_printf(1, 7, "[color=gray]4. Unicode:[/color] Latin Русский Ελληνικά");

	// Composite (overlay) tiles
	n = terminal_printf(1, 9, "[color=gray]5. Tile overlay: ");
	terminal_printf(n+1, 9, "a+  = a, a+  = a, a vs. [color=red]ä");
	terminal_printf(n+1, 9, "[color=red]  /   /    ▔   ▔        [/color]a");

	// Unicode Box Drawing characters
	terminal_printf(1, 11, "[color=gray]6. Box drawing:");
	const char* box_lines[] =
	{
		"       ┌──┬───┐      ╔═════╗ ",
		" ┌───┬─┘  │   ├──┐   ╟──┐  ║ ",
		" └─┐ └─┐  ├───┘  │   ║  └──╢ ",
		"   └───┴──┴──────┘   ╚═════╝ "
	};
	for ( size_t i = 0; i < sizeof(box_lines)/sizeof(box_lines[i]); i++ )
	{
		terminal_printf(1, 12+i, "%s", box_lines[i]);
	}

	// Box drawing + overlay application
	terminal_printf(1, 17, "[color=gray]7. Box drawing + overlay:");
	terminal_color(0xFF006000);
	for ( int y = 0; y < 6; y++ )
	{
		for ( int x = 0; x < 19; x++ )
		{
			terminal_put(1+x, 18+y, 'A'+(x+y)%26);
		}
	}
	DrawOverlayRectangle(3, 19, 15, 4, 0xFFFFFFFF, 0xA0909090);
	terminal_printf(4, 20, "[color=white]Itym:\nHeavy draggon");

	terminal_printf(40, 17, "[color=gray]8. Font supplement:");
	terminal_printf(40, 19, "fire ([color=red][uE001][/color]) - water ([color=lighter blue][uE004][/color]) - earth ([color=dark green][uE00F][/color])");
	terminal_printf(40, 20, "\uE001\uE002\uE003, \uE004\uE005\uE006\uE007\uE008! \uE009\uE00A\uE00B \uE00C \uE00D\uE00E\uE00F\uE010.");

	terminal_refresh();

	int key = 0;
	do
	{
		key = terminal_get();
	}
	while ( key != VK_CLOSE && key != VK_ESCAPE );
}
示例#24
0
文件: Utility.c 项目: scrat101/Alo2
void panic(const char* msg) { 
	terminal_printf("KERNEL PANIC: %s", msg);  
	interrupts_disable();  
	hang();  
}; 
示例#25
0
void handler_sigint (int sig) {
    if (builtin_waiting) {
        terminal_printf("\n"); // Retour a la ligne après le symbole de controle
        builtin_waiting = false;
    }
}
示例#26
0
static void version(void)
{
	terminal_printf("LastPass CLI v" LASTPASS_CLI_VERSION "\n");
}