Index: uspace/lib/fs/libfs.c =================================================================== --- uspace/lib/fs/libfs.c (revision 9934f7d3082d2ffdd107cc0c78d61d504b0f401e) +++ uspace/lib/fs/libfs.c (revision efcebe1bce63b6779458eadc2fd6f252ab7cd703) @@ -45,4 +45,5 @@ #include #include +#include #define on_error(rc, action) \ @@ -61,4 +62,225 @@ } while (0) +static fs_reg_t reg; + +static vfs_out_ops_t *vfs_out_ops = NULL; +static libfs_ops_t *libfs_ops = NULL; + +static void libfs_mount(libfs_ops_t *, fs_handle_t, ipc_callid_t, ipc_call_t *); +static void libfs_unmount(libfs_ops_t *, ipc_callid_t, ipc_call_t *); +static void libfs_lookup(libfs_ops_t *, fs_handle_t, ipc_callid_t, + ipc_call_t *); +static void libfs_stat(libfs_ops_t *, fs_handle_t, ipc_callid_t, ipc_call_t *); +static void libfs_open_node(libfs_ops_t *, fs_handle_t, ipc_callid_t, + ipc_call_t *); + +static void vfs_out_mounted(ipc_callid_t rid, ipc_call_t *req) +{ + devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req); + char *opts; + int rc; + + /* Accept the mount options. */ + rc = async_data_write_accept((void **) &opts, true, 0, 0, 0, NULL); + if (rc != EOK) { + async_answer_0(rid, rc); + return; + } + + fs_index_t index; + aoff64_t size; + unsigned lnkcnt; + rc = vfs_out_ops->mounted(devmap_handle, opts, &index, &size, &lnkcnt); + + if (rc == EOK) // FIXME: size is 64-bit + async_answer_3(rid, EOK, index, size, lnkcnt); + else + async_answer_0(rid, rc); + + free(opts); +} + +static void vfs_out_mount(ipc_callid_t rid, ipc_call_t *req) +{ + libfs_mount(libfs_ops, reg.fs_handle, rid, req); +} + +static void vfs_out_unmounted(ipc_callid_t rid, ipc_call_t *req) +{ + devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req); + int rc; + + rc = vfs_out_ops->unmounted(devmap_handle); + + async_answer_0(rid, rc); +} + +static void vfs_out_unmount(ipc_callid_t rid, ipc_call_t *req) +{ + + libfs_unmount(libfs_ops, rid, req); +} + +static void vfs_out_lookup(ipc_callid_t rid, ipc_call_t *req) +{ + libfs_lookup(libfs_ops, reg.fs_handle, rid, req); +} + +static void vfs_out_read(ipc_callid_t rid, ipc_call_t *req) +{ + devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req); + fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req); + aoff64_t pos = (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*req), + IPC_GET_ARG4(*req)); + size_t rbytes; + int rc; + + rc = vfs_out_ops->read(devmap_handle, index, pos, &rbytes); + + if (rc == EOK) + async_answer_1(rid, EOK, rbytes); + else + async_answer_0(rid, rc); +} + +static void vfs_out_write(ipc_callid_t rid, ipc_call_t *req) +{ + devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req); + fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req); + aoff64_t pos = (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*req), + IPC_GET_ARG4(*req)); + size_t wbytes; + aoff64_t nsize; + int rc; + + rc = vfs_out_ops->write(devmap_handle, index, pos, &wbytes, &nsize); + + if (rc == EOK) // FIXME: nsize is 64-bit + async_answer_2(rid, EOK, wbytes, nsize); + else + async_answer_0(rid, rc); +} + +static void vfs_out_truncate(ipc_callid_t rid, ipc_call_t *req) +{ + devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req); + fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req); + aoff64_t size = (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*req), + IPC_GET_ARG4(*req)); + int rc; + + rc = vfs_out_ops->truncate(devmap_handle, index, size); + + async_answer_0(rid, rc); +} + +static void vfs_out_close(ipc_callid_t rid, ipc_call_t *req) +{ + devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req); + fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req); + int rc; + + rc = vfs_out_ops->close(devmap_handle, index); + + async_answer_0(rid, rc); +} + +static void vfs_out_destroy(ipc_callid_t rid, ipc_call_t *req) +{ + devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req); + fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req); + int rc; + + rc = vfs_out_ops->destroy(devmap_handle, index); + + async_answer_0(rid, rc); +} + +static void vfs_out_open_node(ipc_callid_t rid, ipc_call_t *req) +{ + libfs_open_node(libfs_ops, reg.fs_handle, rid, req); +} + +static void vfs_out_stat(ipc_callid_t rid, ipc_call_t *req) +{ + libfs_stat(libfs_ops, reg.fs_handle, rid, req); +} + +static void vfs_out_sync(ipc_callid_t rid, ipc_call_t *req) +{ + devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req); + fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req); + int rc; + + rc = vfs_out_ops->sync(devmap_handle, index); + + async_answer_0(rid, rc); +} + +static void vfs_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg) +{ + if (iid) { + /* + * This only happens for connections opened by + * IPC_M_CONNECT_ME_TO calls as opposed to callback connections + * created by IPC_M_CONNECT_TO_ME. + */ + async_answer_0(iid, EOK); + } + + while (true) { + ipc_call_t call; + ipc_callid_t callid = async_get_call(&call); + + if (!IPC_GET_IMETHOD(call)) + return; + + switch (IPC_GET_IMETHOD(call)) { + case VFS_OUT_MOUNTED: + vfs_out_mounted(callid, &call); + break; + case VFS_OUT_MOUNT: + vfs_out_mount(callid, &call); + break; + case VFS_OUT_UNMOUNTED: + vfs_out_unmounted(callid, &call); + break; + case VFS_OUT_UNMOUNT: + vfs_out_unmount(callid, &call); + break; + case VFS_OUT_LOOKUP: + vfs_out_lookup(callid, &call); + break; + case VFS_OUT_READ: + vfs_out_read(callid, &call); + break; + case VFS_OUT_WRITE: + vfs_out_write(callid, &call); + break; + case VFS_OUT_TRUNCATE: + vfs_out_truncate(callid, &call); + break; + case VFS_OUT_CLOSE: + vfs_out_close(callid, &call); + break; + case VFS_OUT_DESTROY: + vfs_out_destroy(callid, &call); + break; + case VFS_OUT_OPEN_NODE: + vfs_out_open_node(callid, &call); + break; + case VFS_OUT_STAT: + vfs_out_stat(callid, &call); + break; + case VFS_OUT_SYNC: + vfs_out_sync(callid, &call); + break; + default: + async_answer_0(callid, ENOTSUP); + break; + } + } +} + /** Register file system server. * @@ -68,16 +290,14 @@ * * @param sess Session for communication with VFS. - * @param reg File system registration structure. It will be - * initialized by this function. * @param info VFS info structure supplied by the file system * implementation. - * @param conn Connection fibril for handling all calls originating in - * VFS. + * @param vops Address of the vfs_out_ops_t structure. + * @param lops Address of the libfs_ops_t structure. * * @return EOK on success or a non-zero error code on errror. * */ -int fs_register(async_sess_t *sess, fs_reg_t *reg, vfs_info_t *info, - async_client_conn_t conn) +int fs_register(async_sess_t *sess, vfs_info_t *info, vfs_out_ops_t *vops, + libfs_ops_t *lops) { /* @@ -104,13 +324,19 @@ /* + * Set VFS_OUT and libfs operations. + */ + vfs_out_ops = vops; + libfs_ops = lops; + + /* * Ask VFS for callback connection. */ - async_connect_to_me(exch, 0, 0, 0, conn, NULL); + async_connect_to_me(exch, 0, 0, 0, vfs_connection, NULL); /* * Allocate piece of address space for PLB. */ - reg->plb_ro = as_get_mappable_page(PLB_SIZE); - if (!reg->plb_ro) { + reg.plb_ro = as_get_mappable_page(PLB_SIZE); + if (!reg.plb_ro) { async_exchange_end(exch); async_wait_for(req, NULL); @@ -121,5 +347,5 @@ * Request sharing the Path Lookup Buffer with VFS. */ - rc = async_share_in_start_0_0(exch, reg->plb_ro, PLB_SIZE); + rc = async_share_in_start_0_0(exch, reg.plb_ro, PLB_SIZE); async_exchange_end(exch); @@ -134,5 +360,5 @@ */ async_wait_for(req, NULL); - reg->fs_handle = (int) IPC_GET_ARG1(answer); + reg.fs_handle = (int) IPC_GET_ARG1(answer); /* @@ -140,5 +366,5 @@ * the same connection fibril as well. */ - async_set_client_connection(conn); + async_set_client_connection(vfs_connection); return IPC_GET_RETVAL(answer); @@ -151,10 +377,10 @@ void libfs_mount(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid, - ipc_call_t *request) -{ - devmap_handle_t mp_devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request); - fs_index_t mp_fs_index = (fs_index_t) IPC_GET_ARG2(*request); - fs_handle_t mr_fs_handle = (fs_handle_t) IPC_GET_ARG3(*request); - devmap_handle_t mr_devmap_handle = (devmap_handle_t) IPC_GET_ARG4(*request); + ipc_call_t *req) +{ + devmap_handle_t mp_devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req); + fs_index_t mp_fs_index = (fs_index_t) IPC_GET_ARG2(*req); + fs_handle_t mr_fs_handle = (fs_handle_t) IPC_GET_ARG3(*req); + devmap_handle_t mr_devmap_handle = (devmap_handle_t) IPC_GET_ARG4(*req); async_sess_t *mountee_sess = async_clone_receive(EXCHANGE_PARALLEL); @@ -212,8 +438,8 @@ } -void libfs_unmount(libfs_ops_t *ops, ipc_callid_t rid, ipc_call_t *request) -{ - devmap_handle_t mp_devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request); - fs_index_t mp_fs_index = (fs_index_t) IPC_GET_ARG2(*request); +void libfs_unmount(libfs_ops_t *ops, ipc_callid_t rid, ipc_call_t *req) +{ + devmap_handle_t mp_devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req); + fs_index_t mp_fs_index = (fs_index_t) IPC_GET_ARG2(*req); fs_node_t *fn; int res; @@ -259,4 +485,9 @@ } +static char plb_get_char(unsigned pos) +{ + return reg.plb_ro[pos % PLB_SIZE]; +} + /** Lookup VFS triplet by name in the file system name space. * @@ -273,12 +504,12 @@ */ void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid, - ipc_call_t *request) -{ - unsigned int first = IPC_GET_ARG1(*request); - unsigned int last = IPC_GET_ARG2(*request); + ipc_call_t *req) +{ + unsigned int first = IPC_GET_ARG1(*req); + unsigned int last = IPC_GET_ARG2(*req); unsigned int next = first; - devmap_handle_t devmap_handle = IPC_GET_ARG3(*request); - int lflag = IPC_GET_ARG4(*request); - fs_index_t index = IPC_GET_ARG5(*request); + devmap_handle_t devmap_handle = IPC_GET_ARG3(*req); + int lflag = IPC_GET_ARG4(*req); + fs_index_t index = IPC_GET_ARG5(*req); char component[NAME_MAX + 1]; int len; @@ -298,5 +529,6 @@ async_exch_t *exch = async_exchange_begin(cur->mp_data.sess); async_forward_slow(rid, exch, VFS_OUT_LOOKUP, next, last, - cur->mp_data.devmap_handle, lflag, index, IPC_FF_ROUTE_FROM_ME); + cur->mp_data.devmap_handle, lflag, index, + IPC_FF_ROUTE_FROM_ME); async_exchange_end(exch); @@ -306,5 +538,5 @@ /* Eat slash */ - if (ops->plb_get_char(next) == '/') + if (plb_get_char(next) == '/') next++; @@ -319,5 +551,5 @@ /* Collect the component */ len = 0; - while ((next <= last) && (ops->plb_get_char(next) != '/')) { + while ((next <= last) && (plb_get_char(next) != '/')) { if (len + 1 == NAME_MAX) { /* Component length overflow */ @@ -325,5 +557,5 @@ goto out; } - component[len++] = ops->plb_get_char(next); + component[len++] = plb_get_char(next); /* Process next character */ next++; @@ -357,6 +589,6 @@ async_exch_t *exch = async_exchange_begin(tmp->mp_data.sess); - async_forward_slow(rid, exch, VFS_OUT_LOOKUP, next, last, - tmp->mp_data.devmap_handle, lflag, index, + async_forward_slow(rid, exch, VFS_OUT_LOOKUP, next, + last, tmp->mp_data.devmap_handle, lflag, index, IPC_FF_ROUTE_FROM_ME); async_exchange_end(exch); @@ -451,5 +683,5 @@ len = 0; while (next <= last) { - if (ops->plb_get_char(next) == '/') { + if (plb_get_char(next) == '/') { /* More than one component */ async_answer_0(rid, ENOENT); @@ -463,5 +695,5 @@ } - component[len++] = ops->plb_get_char(next); + component[len++] = plb_get_char(next); /* Process next character */ next++; @@ -637,5 +869,6 @@ rc = ops->node_open(fn); aoff64_t size = ops->size_get(fn); - async_answer_4(rid, rc, LOWER32(size), UPPER32(size), ops->lnkcnt_get(fn), + async_answer_4(rid, rc, LOWER32(size), UPPER32(size), + ops->lnkcnt_get(fn), (ops->is_file(fn) ? L_FILE : 0) | (ops->is_directory(fn) ? L_DIRECTORY : 0)); Index: uspace/lib/fs/libfs.h =================================================================== --- uspace/lib/fs/libfs.h (revision 9934f7d3082d2ffdd107cc0c78d61d504b0f401e) +++ uspace/lib/fs/libfs.h (revision efcebe1bce63b6779458eadc2fd6f252ab7cd703) @@ -43,4 +43,17 @@ typedef struct { + int (* mounted)(devmap_handle_t, const char *, fs_index_t *, aoff64_t *, + unsigned *); + int (* unmounted)(devmap_handle_t); + int (* read)(devmap_handle_t, fs_index_t, aoff64_t, size_t *); + int (* write)(devmap_handle_t, fs_index_t, aoff64_t, size_t *, + aoff64_t *); + int (* truncate)(devmap_handle_t, fs_index_t, aoff64_t); + int (* close)(devmap_handle_t, fs_index_t); + int (* destroy)(devmap_handle_t, fs_index_t); + int (* sync)(devmap_handle_t, fs_index_t); +} vfs_out_ops_t; + +typedef struct { bool mp_active; async_sess_t *sess; @@ -71,11 +84,10 @@ int (* has_children)(bool *, fs_node_t *); /* - * The second set of methods are usually mere getters that do not return - * an integer error code. + * The second set of methods are usually mere getters that do not + * return an integer error code. */ fs_index_t (* index_get)(fs_node_t *); aoff64_t (* size_get)(fs_node_t *); unsigned int (* lnkcnt_get)(fs_node_t *); - char (* plb_get_char)(unsigned pos); bool (* is_directory)(fs_node_t *); bool (* is_file)(fs_node_t *); @@ -88,15 +100,8 @@ } fs_reg_t; -extern int fs_register(async_sess_t *, fs_reg_t *, vfs_info_t *, - async_client_conn_t); +extern int fs_register(async_sess_t *, vfs_info_t *, vfs_out_ops_t *, + libfs_ops_t *); extern void fs_node_initialize(fs_node_t *); - -extern void libfs_mount(libfs_ops_t *, fs_handle_t, ipc_callid_t, ipc_call_t *); -extern void libfs_unmount(libfs_ops_t *, ipc_callid_t, ipc_call_t *); -extern void libfs_lookup(libfs_ops_t *, fs_handle_t, ipc_callid_t, ipc_call_t *); -extern void libfs_stat(libfs_ops_t *, fs_handle_t, ipc_callid_t, ipc_call_t *); -extern void libfs_open_node(libfs_ops_t *, fs_handle_t, ipc_callid_t, - ipc_call_t *); #endif