/**
* Usage: -f file -i - create a filesystem with name 'file'
* Usage: -f file -o - open a filesystem 'file'
* Usage: -f file -c path - create a file with path 'path' in a filesystem 'file'
*/
int main(int argc, char ** argv) {
char *value = 0;
int option;
while ((option = getopt (argc, argv, "f:ioc:")) != -1) {
switch(option) {
case 'f':
value = optarg;
break;
case 'i':
if(value != 0) {
init_file_system(value);
}
break;
case 'o':
open_file_system(value);
break;
case 'c':
creat_file(value, optarg);
break;
}
}
int fdfs = simplefs_openfs("filesystem");
simplefs_creat("/a.txt", fdfs);
int fd = simplefs_open("/a.txt", READ_AND_WRITE, fdfs);
printf("Result of simplefs_open %d\n", fd);
printf("Wrint to file result %d", simplefs_write(fd, "adam to glupi programista", 15, fdfs));
char result[20];
simplefs_lseek(fd, SEEK_SET,0,fdfs);
printf("Readig from file %d", simplefs_read(fd, result, 10, fdfs));
result[10] = '\0';
printf("================Read================\n %s\n", result);
return 0;
}
struct file_handle *open_file(const char *path)
{
int directory_index;
struct file_handle *handle;
if (!initialized)
{
if (init_file_system() < 0)
return -1;
initialized = 1;
}
for (directory_index = 0; directory_index < directory->num_directory_entries; directory_index++)
{
struct directory_entry *entry = directory->dir + directory_index;
if (strcmp(entry->name, path) == 0)
{
handle = (struct file_handle*) malloc(sizeof(struct file_handle));
handle->base_location = entry->start_offset;
handle->length = entry->length;
return entry;
}
}
return 0;
}
void
os_init_cont(void) {
/* Reset the GDT. Although user processes in Nanos run in Ring 0,
they have their own virtual address space. Therefore, the
old GDT located in physical address 0x7C00 cannot be used again. */
init_segment();
/* Initialize the serial port. After that, you can use printk() */
init_serial();
/* Set up interrupt and exception handlers,
just as we did in the game. */
init_idt();
/* Initialize the intel 8259 PIC. */
//The Intel 8259 is a Programmable Interrupt Controller (PIC)
init_intr();
/**
initialize kmalloc -- have to initialize it before init
process, for using it in allocating memory for PCB
*/
init_kmalloc();
// make it NOINTR, can receive msg, can schedule
init_idle();
NOINTR;
/**
init_driver() have to before init_file_system() for FM have
to send message to `ide` to read file system
*/
init_driver();
init_manager();
NOINTR;
init_error_msg();
// init_proc() and init_manager() can replace??
// solved by split set count_of_lock out of init_proc();
//more_frequent();
// init empty thread
init_proc_test();
// here is to initialize shell process, which must later
// than init_manager -- for it will send message to
// managers
//ram_user_process();
// @checked: move from locked state to unlocked state
init_file_system();
unlock(); // set interrupt enabled
INTR;
/**
init_file_system() have to before init_proc()
for init_proc() will using the `default_cwd` which is
initialized by FM
*/
/* Initialize the state of process idle, ie the running
process for set up right lock num to avoid other
initialization enable the interrupt and cause problem
*/
// @checked: move from locked state to unlocked state
welcome();
user_process();
// set idle not to using cpu time
// for it is originally set to sleep when send message
current->state = SLEEPED;
/* This context now becomes the idle process. */
while (1) {
printk("!");
wait_intr();
}
}
void prepare_for_new_binary_download()
{
instaMsg.singletonUtilityFs.deleteFile(&(instaMsg.singletonUtilityFs), TEMP_FILE_NAME);
init_file_system(&fs, TEMP_FILE_NAME);
}
/* Check if MAGIC is valid and print the Multiboot information structure
pointed by ADDR. */
void
entry (unsigned long magic, unsigned long addr)
{
multiboot_info_t *mbi;
/* Clear the screen. */
clear();
/* Am I booted by a Multiboot-compliant boot loader? */
if (magic != MULTIBOOT_BOOTLOADER_MAGIC)
{
printf ("Invalid magic number: 0x%#x\n", (unsigned) magic);
return;
}
/* Set MBI to the address of the Multiboot information structure. */
mbi = (multiboot_info_t *) addr;
/* Print out the flags. */
printf ("flags = 0x%#x\n", (unsigned) mbi->flags);
/* Are mem_* valid? */
if (CHECK_FLAG (mbi->flags, 0))
printf ("mem_lower = %uKB, mem_upper = %uKB\n",
(unsigned) mbi->mem_lower, (unsigned) mbi->mem_upper);
/* Is boot_device valid? */
if (CHECK_FLAG (mbi->flags, 1))
printf ("boot_device = 0x%#x\n", (unsigned) mbi->boot_device);
/* Is the command line passed? */
if (CHECK_FLAG (mbi->flags, 2))
printf ("cmdline = %s\n", (char *) mbi->cmdline);
if (CHECK_FLAG (mbi->flags, 3)) {
int mod_count = 0;
int i;
module_t* mod = (module_t*)mbi->mods_addr;
while(mod_count < mbi->mods_count) {
printf("Module %d loaded at address: 0x%#x\n", mod_count, (unsigned int)mod->mod_start);
printf("Module %d ends at address: 0x%#x\n", mod_count, (unsigned int)mod->mod_end);
printf("First few bytes of module:\n");
for(i = 0; i<16; i++) {
printf("0x%x ", *((char*)(mod->mod_start+i)));
}
printf("\n");
mod_count++;
}
}
/* Bits 4 and 5 are mutually exclusive! */
if (CHECK_FLAG (mbi->flags, 4) && CHECK_FLAG (mbi->flags, 5))
{
printf ("Both bits 4 and 5 are set.\n");
return;
}
/* Is the section header table of ELF valid? */
if (CHECK_FLAG (mbi->flags, 5))
{
elf_section_header_table_t *elf_sec = &(mbi->elf_sec);
printf ("elf_sec: num = %u, size = 0x%#x,"
" addr = 0x%#x, shndx = 0x%#x\n",
(unsigned) elf_sec->num, (unsigned) elf_sec->size,
(unsigned) elf_sec->addr, (unsigned) elf_sec->shndx);
}
/* Are mmap_* valid? */
if (CHECK_FLAG (mbi->flags, 6))
{
memory_map_t *mmap;
printf ("mmap_addr = 0x%#x, mmap_length = 0x%x\n",
(unsigned) mbi->mmap_addr, (unsigned) mbi->mmap_length);
for (mmap = (memory_map_t *) mbi->mmap_addr;
(unsigned long) mmap < mbi->mmap_addr + mbi->mmap_length;
mmap = (memory_map_t *) ((unsigned long) mmap
+ mmap->size + sizeof (mmap->size)))
printf (" size = 0x%x, base_addr = 0x%#x%#x\n"
" type = 0x%x, length = 0x%#x%#x\n",
(unsigned) mmap->size,
(unsigned) mmap->base_addr_high,
(unsigned) mmap->base_addr_low,
(unsigned) mmap->type,
(unsigned) mmap->length_high,
(unsigned) mmap->length_low);
}
/* Construct an LDT entry in the GDT */
{
seg_desc_t the_ldt_desc;
the_ldt_desc.granularity = 0;
the_ldt_desc.opsize = 1;
the_ldt_desc.reserved = 0;
the_ldt_desc.avail = 0;
the_ldt_desc.present = 1;
the_ldt_desc.dpl = 0x0;
the_ldt_desc.sys = 0;
the_ldt_desc.type = 0x2;
SET_LDT_PARAMS(the_ldt_desc, &ldt, ldt_size);
ldt_desc_ptr = the_ldt_desc;
lldt(KERNEL_LDT);
}
/* Construct a TSS entry in the GDT */
{
seg_desc_t the_tss_desc;
the_tss_desc.granularity = 0;
the_tss_desc.opsize = 0;
the_tss_desc.reserved = 0;
the_tss_desc.avail = 0;
the_tss_desc.seg_lim_19_16 = TSS_SIZE & 0x000F0000;
the_tss_desc.present = 1;
the_tss_desc.dpl = 0x0;
the_tss_desc.sys = 0;
the_tss_desc.type = 0x9;
the_tss_desc.seg_lim_15_00 = TSS_SIZE & 0x0000FFFF;
SET_TSS_PARAMS(the_tss_desc, &tss, tss_size);
tss_desc_ptr = the_tss_desc;
tss.ldt_segment_selector = KERNEL_LDT;
tss.ss0 = KERNEL_DS;
tss.esp0 = 0x800000;
ltr(KERNEL_TSS);
}
/* Initialize IDT and fill its entries */
init_idt();
/* Init the PIC */
i8259_init();
/* Enable RTC interrupt */
rtc_init();
enable_irq(RTC_IRQ);
/* Enbale Keyboard interrupt */
enable_irq(KEYBOARD_IRQ);
/*Enable PIT interrupt*/
enable_irq(PIT_IRQ);
/* Initialize devices, memory, filesystem, enable device interrupts on the
* PIC, any other initialization stuff... */
/* Initialize the Read-only File System */
module_t* fs_mod = (module_t*)mbi->mods_addr;
init_file_system(fs_mod->mod_start, fs_mod->mod_end);
/* Initialize Paging */
init_paging();
/* Enable interrupts */
/* Do not enable the following until after you have set up your
* IDT correctly otherwise QEMU will triple fault and simple close
* without showing you any output */
printf("Enabling Interrupts\n");
sti();
terminal_open();
/* Test file_system driver */
//test_file_system_driver();
//Test for pit
pit_init(0,2,20);
/* Test the RTC driver */
//rtc_test();
while(1) {
int8_t exec_cmd[15] = "shell";
asm volatile("movl $2, %%eax; movl %0, %%ebx;int $0x80;"::"b"(exec_cmd));
printf("ended exec!\n");
}
// asm volatile("movl $1, %%eax; movl %0, %%ebx;int $0x80;"::"b"(exec_cmd));
/* Test terminal & keyboard driver */
//test_terminal();
/* Execute the first program (`shell') ... */
//execlp("shell", NULL);
/* Spin (nicely, so we don't chew up cycles) */
asm volatile(".1: hlt; jmp .1;");
//printf("after volatile\n");
}
