/* Initializes the file system module. If FORMAT is true, reformats the file system. */ void filesys_init (bool format) { fs_device = block_get_role (BLOCK_FILESYS); if (fs_device == NULL) PANIC ("No file system device found, can't initialize file system."); if (!block_cache_init (&fs_cache, fs_device, FS_CACHE_SIZE, FS_CACHE_IN_USERSPACE)) PANIC ("Filesys cache could not be intialized."); if (!pifs_init (&fs_pifs, &fs_cache)) PANIC ("PIFS could not be intialized."); if (format) { printf ("Formatting filesystem with PIFS.\n"); if (!pifs_format (&fs_pifs)) PANIC ("Your device is either too big or too small."); } else { printf ("Using a PIFS filesystem.\n"); if (!pifs_sanity_check (&fs_pifs)) PANIC ("PIFS's basic sanity check failed."); } printf ("Initialized filesystem.\n"); fs_initialized = true; }
void blockdev_init(void) { block_major = dm_device_register(&__kdev_block); block_cache_init(); block_buffer_init(); loader_add_kernel_symbol(blockdev_register); loader_add_kernel_symbol(blockdev_register_partition); }
// Init status_t HaikuKernelFileSystem::Init() { status_t error = fLock.InitCheck(); if (error != B_OK) RETURN_ERROR(error); // init condition variables condition_variable_init(); // TODO: Call the cleanup methods, if something goes wrong! // init block cache error = block_cache_init(); if (error != B_OK) RETURN_ERROR(error); // init file map error = file_map_init(); if (error != B_OK) RETURN_ERROR(error); // create I/O request map fIORequests = new(std::nothrow) IORequestTable; if (fIORequests == NULL) RETURN_ERROR(B_NO_MEMORY); error = fIORequests->Init(); if (error != B_OK) RETURN_ERROR(error); // create the node capabilites map fNodeCapabilities = new(std::nothrow) NodeCapabilitiesTable; if (fNodeCapabilities == NULL) RETURN_ERROR(B_NO_MEMORY); error = fNodeCapabilities->Init(); if (error != B_OK) RETURN_ERROR(error); // call the kernel module initialization (if any) if (!fFSModule->info.std_ops) return B_OK; error = fFSModule->info.std_ops(B_MODULE_INIT); if (error != B_OK) RETURN_ERROR(error); return B_OK; }
/* Initializes the file system module. If FORMAT is true, reformats the file system. */ void filesys_init (bool format) { fs_device = block_get_role (BLOCK_FILESYS); if (fs_device == NULL) PANIC ("No file system device found, can't initialize file system."); block_cache_init (); inode_init (); free_map_init (); if (format) do_format (); free_map_open (); lock_init (&cur_name_list_lock); list_init (&cur_name_list); }
void _main() { mem_extent_t *ramext; u8 sn[6]; u32 cpu_clk_hz = 0; rtc_time_t tm; s32 ret; /* This section runs with interrupts disabled. The boot console is not available in this section. */ preempt_disable(); /* Copy kernel read/write data areas into kernel RAM */ memcpy(&_sdata, &_etext, &_edata - &_sdata); /* Copy .data section to kernel RAM */ bzero(&_sbss, &_ebss - &_sbss); /* Initialise .bss section */ /* Begin platform initialisation */ if(plat_init() != SUCCESS) boot_early_fail(1); if(plat_mem_detect() != SUCCESS) /* Detect installed RAM, initialise memory extents */ boot_early_fail(2); /* Initialise kernel slabs */ slab_init(&_ebss); /* Slabs sit after the .bss section */ /* Initialise kernel heap */ kmeminit(g_slab_end, mem_get_highest_addr(MEM_EXTENT_KERN | MEM_EXTENT_RAM) - KERNEL_STACK_LEN); /* Initialise user heap. Place it in the largest user RAM extent. */ ramext = mem_get_largest_extent(MEM_EXTENT_USER | MEM_EXTENT_RAM); umeminit(ramext->base, ramext->base + ramext->len); /* By default, all exceptions cause a context-dump followed by a halt. */ cpu_irq_init_table(); /* Initialise device tree */ if(dev_init() != SUCCESS) boot_early_fail(3); /* It's not yet possible to initialise the real (platform) console because devices haven't been enumerated and interrupts are disabled. In the meantime, create a temporary in-memory kernel console device to capture output from the boot process. */ if(early_boot_console_init() != SUCCESS) boot_early_fail(4); printf("%s\nplatform: %s\n", g_warmup_message, plat_get_name()); printf("%uMB RAM detected\n", (mem_get_total_size(MEM_EXTENT_USER | MEM_EXTENT_RAM) + mem_get_total_size(MEM_EXTENT_KERN | MEM_EXTENT_RAM)) >> 20); /* === Initialise peripherals - phase 2 === */ if(dev_enumerate() != SUCCESS) boot_early_fail(5); /* Initialise the console */ if(plat_console_init() != SUCCESS) boot_early_fail(6); ret = sched_init("[sys]"); /* Init scheduler and create system process */ /* Enable interrupts and continue booting */ preempt_enable(); /* Copy the contents of the temporary console to the real console; close the temp console. */ early_boot_console_close(); /* Activate red LED while the boot process continues */ plat_led_off(LED_ALL); plat_led_on(LED_RED); /* Device enumeration is done; interrupts are enabled, and the console should be functional. Booting continues... */ /* Zero any user RAM extents. This happens after init'ing the DUART, because beeper. */ /* put("Clearing user RAM: "); mem_zero_extents(MEM_EXTENT_USER | MEM_EXTENT_RAM); puts("done"); */ /* Initialise the block cache, then scan mass-storage devices for partitions */ block_cache_init(2039); partition_init(); boot_list_mass_storage(); boot_list_partitions(); /* ret is set by the call to sched_init(), above */ if(ret != SUCCESS) printf("sched: init failed: %s\n", kstrerror(ret)); ret = vfs_init(); if(ret != SUCCESS) printf("vfs: init failed: %s\n", kstrerror(ret)); /* Display approximate CPU clock speed */ if(plat_get_cpu_clock(&cpu_clk_hz) == SUCCESS) printf("\nCPU fclk ~%2u.%uMHz\n", cpu_clk_hz / 1000000, (cpu_clk_hz % 1000000) / 100000); /* Initialise tick handler */ tick_init(); /* Display memory information */ printf("%u bytes of kernel heap memory available\n" "%u bytes of user memory available\n", kfreemem(), ufreemem()); /* Display platform serial number */ if(plat_get_serial_number(sn) == SUCCESS) { printf("Hardware serial number %02X%02X%02X%02X%02X%02X\n", sn[0], sn[1], sn[2], sn[3], sn[4], sn[5]); } /* Display the current date and time */ if(get_time(&tm) == SUCCESS) { char timebuf[12], datebuf[32]; if((time_iso8601(&tm, timebuf, sizeof(timebuf)) == SUCCESS) && (date_long(&tm, datebuf, sizeof(datebuf)) == SUCCESS)) printf("%s %s\n", timebuf, datebuf); else puts("Date/time invalid - please set clock"); } /* Create housekeeper process */ // proc_create(0, 0, "[hk]", NULL, housekeeper, 0, 0, PROC_TYPE_KERNEL, NULL, NULL); /* Initialise networking system */ ret = net_init(); if(ret != SUCCESS) printf("net: init failed: %s\n", kstrerror(ret)); /* Startup complete - activate green LED */ plat_led_off(LED_RED); plat_led_on(LED_GREEN); monitor(); /* start interactive "shell" thing */ cpu_halt(); /* should never be reached */ }
static int udf_mounted(service_id_t service_id, const char *opts, fs_index_t *index, aoff64_t *size, unsigned *linkcnt) { enum cache_mode cmode; /* Check for option enabling write through. */ if (str_cmp(opts, "wtcache") == 0) cmode = CACHE_MODE_WT; else cmode = CACHE_MODE_WB; udf_instance_t *instance = malloc(sizeof(udf_instance_t)); if (!instance) return ENOMEM; instance->sector_size = 0; /* Check for block size. Will be enhanced later */ if (str_cmp(opts, "bs=512") == 0) instance->sector_size = 512; else if (str_cmp(opts, "bs=1024") == 0) instance->sector_size = 1024; else if (str_cmp(opts, "bs=2048") == 0) instance->sector_size = 2048; /* initialize block cache */ int rc = block_init(service_id, MAX_SIZE); if (rc != EOK) return rc; rc = fs_instance_create(service_id, instance); if (rc != EOK) { free(instance); block_fini(service_id); return rc; } instance->service_id = service_id; instance->open_nodes_count = 0; /* Check Volume Recognition Sequence */ rc = udf_volume_recongnition(service_id); if (rc != EOK) { log_msg(LOG_DEFAULT, LVL_NOTE, "VRS failed"); fs_instance_destroy(service_id); free(instance); block_fini(service_id); return rc; } /* Search for Anchor Volume Descriptor */ udf_anchor_volume_descriptor_t avd; rc = udf_get_anchor_volume_descriptor(service_id, &avd); if (rc != EOK) { log_msg(LOG_DEFAULT, LVL_NOTE, "Anchor read failed"); fs_instance_destroy(service_id); free(instance); block_fini(service_id); return rc; } log_msg(LOG_DEFAULT, LVL_DEBUG, "Volume: Anchor volume descriptor found. Sector size=%" PRIu32, instance->sector_size); log_msg(LOG_DEFAULT, LVL_DEBUG, "Anchor: main sequence [length=%" PRIu32 " (bytes), start=%" PRIu32 " (sector)]", avd.main_extent.length, avd.main_extent.location); log_msg(LOG_DEFAULT, LVL_DEBUG, "Anchor: reserve sequence [length=%" PRIu32 " (bytes), start=%" PRIu32 " (sector)]", avd.reserve_extent.length, avd.reserve_extent.location); /* Initialize the block cache */ rc = block_cache_init(service_id, instance->sector_size, 0, cmode); if (rc != EOK) { fs_instance_destroy(service_id); free(instance); block_fini(service_id); return rc; } /* Read Volume Descriptor Sequence */ rc = udf_read_volume_descriptor_sequence(service_id, avd.main_extent); if (rc != EOK) { log_msg(LOG_DEFAULT, LVL_NOTE, "Volume Descriptor Sequence read failed"); fs_instance_destroy(service_id); free(instance); block_cache_fini(service_id); block_fini(service_id); return rc; } fs_node_t *rfn; rc = udf_node_get(&rfn, service_id, instance->volumes[DEFAULT_VOL].root_dir); if (rc != EOK) { log_msg(LOG_DEFAULT, LVL_NOTE, "Can't create root node"); fs_instance_destroy(service_id); free(instance); block_cache_fini(service_id); block_fini(service_id); return rc; } udf_node_t *node = UDF_NODE(rfn); *index = instance->volumes[DEFAULT_VOL].root_dir; *size = node->data_size; *linkcnt = node->link_cnt; return EOK; }