WebSVN – HelenOS – Diff – /branches/fs/uspace/fs/fs.c

 #include <ipc/ipc.h>
 #include <ipc/services.h>
 #include <ipc/ns.h>
 #include <sysinfo.h>
-#include <stdio.h>
+#include <io/io.h>
-#include <stdlib.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)
+{
-    ipc_callid_t callid;
-    ipc_call_t call;
-    int retval;
+    int result;
     ipc_answer_fast(iid, 0, 0, 0);
-    while (1) {
+    while (1)
+    {
-        callid = async_get_call(&call);
+        prepare_message();
-        switch (IPC_GET_METHOD(call)) {
-        case IPC_M_PHONE_HUNGUP:
+        if (fs_call == IPC_M_PHONE_HUNGUP) {
             ipc_answer_fast(callid, 0,0,0);
             return;
-        case FS_OPEN:
-            //Why doesn't printf do anything in this task?
-            printf("FS_OPEN called");
-            char * f_name = (char *) IPC_GET_ARG1(call);
-            printf("I should open file: %s \n",f_name);
-            retval = 73;
-            break;
-        case FS_READ:
-            printf("FS_READ called");
-            unsigned int file_handle = IPC_GET_ARG1(call);
-            void * buffer = (void *) IPC_GET_ARG2(call);
-            unsigned int count = IPC_GET_ARG3(call);
-            //I still don't know how to copy memory to another task :(
-            //Or can i only map memory?
-            retval = 0;
-            break;
-        default:
-            retval = EINVAL;
+        }
+        if (fs_call == FS_NEW_CONSUMER) {
+            if (!new_consument) {
+                ipc_answer_fast(callid, FS_ECONNECT, 0, 0);
+            }
+            else {
+                result = new_consument_map();
-        ipc_answer_fast(callid, retval, 0, 0);
+                ipc_answer_fast(callid, result, 0, 0);
+                if (!result) {
+                    new_consument = FALSE;
+                }
+            }
+            continue;
+        }
+        if (fs_call == IPC_M_AS_AREA_SEND) {
+            if (!new_consument)
+                ipc_answer_fast(callid, FS_ECONNECT, 0, 0);
+            else {
+                ipc_answer_fast(callid, 0, (uintptr_t)fp->buffer, 0);
+                fp =  &fproc[new_consument];
+                fp->connected = TRUE;
+                new_consument = FALSE;
+            }
+            continue;
+        }
+        if (check_con < 0) {
+            ipc_answer_fast(callid, err_code, 0, 0);
+            check_con = TRUE;
+            continue;
+        }
+        if (FS_IN_RANGE(fs_call)) {
+           result = call_vector[fs_call-FS_BASE]();
+        }
+        else {
+           result = FS_EBADCALL;
+        }
+        ipc_answer_fast(callid, result, 0, 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;
+    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;

Subversion Repositories HelenOS

(root)/branches/fs/uspace/fs/fs.c @ 2391 – Rev 2248 → 2388