/*
* Copyright (c) 2006 Martin Decky
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* - The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/** @addtogroup fs
* @{
*/
/**
* @file fs.c
* @brief File system driver for HelenOS.
*/
#include <ipc/ipc.h>
#include <ipc/services.h>
#include <ipc/ns.h>
#include <sysinfo.h>
#include <io/io.h>
#include <as.h>
#include <ddi.h>
#include <align.h>
#include <bool.h>
#include <errno.h>
#include <async.h>
#include <cap.h>
#include <sys/mman.h>
#include "fs.h"
#include "dir.h"
#include "../console/console.h"
static int fs_call;
static ipc_call_t m_input; /* the input message used for request */
static ipc_callid_t callid; /* caller's number */
static int new_consument; /* if new consumer wants to connect to FS */
static int check_con; /* check of connection of consument */
static void prepare_message(void);
static int load_super(void);
static int new_consument_map(void);
static void fs_connection(ipc_callid_t iid, ipc_call_t *icall)
{
int result = 0;
ipcarg_t arg = 0;
ipc_answer_fast(iid, 0, 0, 0);
while (1)
{
prepare_message();
switch (fs_call)
{
case IPC_M_PHONE_HUNGUP:
ipc_answer_fast(callid, 0,0,0);
return;
case FS_NEW_CONSUMER:
if (!new_consument) {
result = FS_ECONNECT;
}
else {
result = new_consument_map();
if (!result) {
new_consument = FALSE;
}
}
break;
case IPC_M_AS_AREA_SEND:
if (!new_consument)
result = FS_ECONNECT;
else {
result = 0;
arg = (uintptr_t)fp->buffer;
fp = &fproc[new_consument];
fp->connected = TRUE;
new_consument = FALSE;
}
break;
case FS_DROP_CONSUMER:
fproc->connected = FALSE;
fproc->buffer = NULL;
result = 0;
break;
default:
if (check_con < 0) {
result = err_code;
check_con = TRUE;
break;
}
if (FS_IN_RANGE(fs_call)) {
result = call_vector[fs_call-FS_BASE]();
}
else {
result = FS_EBADCALL;
}
break;
}
ipc_answer_fast(callid, result, arg, 0);
arg = 0;
}
}
/* Extracts parameters from message and prepare them for later usage. */
void prepare_message(void)
{
int shift, id_task;
callid = async_get_call(&m_input);
fs_call = IPC_GET_METHOD(m_input);
if (fs_call == IPC_M_AS_AREA_SEND) {
if (!new_consument) {
new_consument = FALSE;
}
return;
}
id_task = IPC_GET_ARG1(m_input);
/* Setup new consument. */
if (fs_call == FS_NEW_CONSUMER) {
if (!new_consument) {
new_consument = id_task;
}
else {
new_consument = FALSE;
}
return;
}
/* Other messages discard process of new consument connecting. */
if (new_consument) {
new_consument = FALSE;
}
if (id_task < 0 || id_task >= NR_PROCS) {
check_con = FS_EINVAL;
return;
}
/* Switch to active consument. */
fp = &fproc[id_task];
/* Check if consument was connected. */
if (!(fp->connected)) {
check_con = FS_ENOTCONNECT;
return;
}
/* Unpacking extended input message into message_params structure. */
unpack_message(&message_params, m_input, fp->buffer);
}
/* Map some memory to the task */
int new_consument_map()
{
size_t size;
task_id_t task_id;
task_id = new_consument;
if (task_id < 0 || task_id >= NR_PROCS) {
return FS_EINVAL;
}
fp = &fproc[task_id];
size = ALIGN_UP(BLOCK_SIZE * sizeof(char), PAGE_SIZE);
fp->buffer = as_get_mappable_page(size, PAGE_COLOR((uintptr_t)fp->buffer));
return TRUE;
}
/* Reads in the superblock from image. */
int load_super(void)
{
super_block_t *sp;
if (!init_super_block())
return FALSE;
sp = get_super();
if (read_super(sp) != OK)
{
print_console("Super block read error\n");
return FALSE;
}
return TRUE;
}
/* Basic initialization. */
static bool fs_init(void)
{
register inode_t *rip;
int bad, i;
bad = 0;
callid = SERVICE_FS;
fp = (fproc_t *)NULL;
print_console("FS initialization...");
/* Block cache initialization. */
if (!init_block())
return FALSE;
/* Loading superblock. */
if (!load_super())
return FALSE;
for (i = 0; i < NR_PROCS; i++) {
if (i == SERVICE_FS)
continue;
fp = &fproc[i];
rip = get_inode(ROOT_INODE);
fp->fp_rootdir = rip;
dup_inode(rip);
fp->fp_workdir = rip;
}
fp = &fproc[SERVICE_FS];
/* Certain relations must hold for the file system to work at all. */
if (SUPER_SIZE > BLOCK_SIZE) {
print_console("SUPER_SIZE > BLOCK_SIZE\n");
bad++;
}
if (BLOCK_SIZE % V1_INODE_SIZE != 0) {
print_console("BLOCK_SIZE mod V1_INODE_SIZE != 0\n");
bad++;
}
if (OPEN_MAX > 127) {
print_console("OPEN_MAX > 127\n");
bad++;
}
if (V1_INODE_SIZE != 32) {
print_console("V1 inode size != 32\n");
bad++;
}
if (V2_INODE_SIZE != 64) {
print_console("V2 inode size != 64\n");
bad++;
}
if (bad)
return FALSE;
/* New consument flag settings. */
new_consument = FALSE;
check_con = FALSE;
print_console("OK\n");
return TRUE;
}
int main(int argc, char **argv)
{
int retval, flags;
unsigned int size;
/* Initializing printing functions. */
if (!init_printing())
return -1;
print_console("FS task\n");
/* Connection to SERVICE_RD service. */
print_console("Connnection to SERVICE_RD...");
if (connect_to_rd(&rd_phone, RD_CONN_ATTEMPTS))
print_console("OK\n");
else {
print_console("FALSE\n");
return -1;
}
/* Creating shared memory for usage with SERVICE_RD. */
print_console("Creating address space area for share with SERVICE_RD task...");
size = ALIGN_UP(BLOCK_SIZE * sizeof(char), PAGE_SIZE);
buffer = mmap(buffer, size, AS_AREA_READ | AS_AREA_WRITE, MAP_SHARED | MAP_ANONYMOUS, 0, 0);
if ((int)buffer < 0) {
print_console_int("As_area_create error %d", (int)buffer);
return -1;
}
print_console("OK\n");
/* Mapping memory to SERVICE_RD. */
print_console("Sending memory to RD_SERVICE...");
flags = 0;
flags = AS_AREA_READ | AS_AREA_WRITE;
retval = async_req_3(rd_phone, IPC_M_AS_AREA_SEND, (uintptr_t)buffer, size, flags, NULL, NULL, NULL);
if (retval < 0) {
print_console_int("%d\n", retval);
return -1;
}
print_console("OK\n");
if (fs_init()) {
ipcarg_t phonead;
async_set_client_connection(fs_connection);
/* Register service at nameserver */
if (ipc_connect_to_me(PHONE_NS, SERVICE_FS, 0, &phonead) != 0)
return -1;
async_manager();
/* Never reached */
return 0;
}
return -1;
}
/**
* @}
*/