Index: uspace/srv/vfs/vfs.c =================================================================== --- uspace/srv/vfs/vfs.c (revision 1b20da07baaa3e3c424f62c927274e676e4295cd) +++ uspace/srv/vfs/vfs.c (revision 34e1206ec4dc79f0592077e3ee270fba91d1eb9d) @@ -62,8 +62,8 @@ ipc_call_t call; ipc_callid_t callid = async_get_call(&call); - + if (!IPC_GET_IMETHOD(call)) break; - + switch (IPC_GET_IMETHOD(call)) { case IPC_M_PAGE_IN: @@ -91,5 +91,5 @@ printf("%s: HelenOS VFS server\n", NAME); - + /* * Initialize VFS node hash table. @@ -100,5 +100,5 @@ return ENOMEM; } - + /* * Allocate and initialize the Path Lookup Buffer. @@ -111,5 +111,5 @@ } memset(plb, 0, PLB_SIZE); - + /* * Set client data constructor and destructor. @@ -138,5 +138,5 @@ async_event_task_subscribe(EVENT_TASK_STATE_CHANGE, notification_handler, NULL); - + /* * Register at the naming service. @@ -147,5 +147,5 @@ return rc; } - + /* * Start accepting connections. Index: uspace/srv/vfs/vfs.h =================================================================== --- uspace/srv/vfs/vfs.h (revision 1b20da07baaa3e3c424f62c927274e676e4295cd) +++ uspace/srv/vfs/vfs.h (revision 34e1206ec4dc79f0592077e3ee270fba91d1eb9d) @@ -110,5 +110,5 @@ */ unsigned refcnt; - + ht_link_t nh_link; /**< Node hash-table link. */ @@ -121,5 +121,5 @@ */ fibril_rwlock_t contents_rwlock; - + struct _vfs_node *mount; } vfs_node_t; @@ -134,5 +134,5 @@ vfs_node_t *node; - + /** Number of file handles referencing this file. */ unsigned refcnt; Index: uspace/srv/vfs/vfs_file.c =================================================================== --- uspace/srv/vfs/vfs_file.c (revision 1b20da07baaa3e3c424f62c927274e676e4295cd) +++ uspace/srv/vfs/vfs_file.c (revision 34e1206ec4dc79f0592077e3ee270fba91d1eb9d) @@ -94,5 +94,5 @@ (void) _vfs_fd_free(vfs_data, i); } - + free(vfs_data->files); @@ -100,5 +100,5 @@ link_t *lnk; vfs_boxed_handle_t *bh; - + lnk = list_first(&vfs_data->passed_handles); list_remove(lnk); @@ -120,5 +120,5 @@ vfs_data->files = NULL; } - + return vfs_data; } @@ -136,16 +136,16 @@ { assert(!file->refcnt); - + async_exch_t *exch = vfs_exchange_grab(file->node->fs_handle); - + ipc_call_t answer; aid_t msg = async_send_2(exch, VFS_OUT_CLOSE, file->node->service_id, file->node->index, &answer); - + vfs_exchange_release(exch); - + errno_t rc; async_wait_for(msg, &rc); - + return IPC_GET_RETVAL(answer); } @@ -179,5 +179,5 @@ * endpoint FS and drop our reference to the underlying VFS node. */ - + if (file->node != NULL) { if (file->open_read || file->open_write) { @@ -196,5 +196,5 @@ if (!vfs_files_init(vfs_data)) return ENOMEM; - + unsigned int i; if (desc) @@ -202,5 +202,5 @@ else i = 0; - + fibril_mutex_lock(&vfs_data->lock); while (true) { @@ -211,34 +211,34 @@ return ENOMEM; } - - + + memset(vfs_data->files[i], 0, sizeof(vfs_file_t)); - + fibril_mutex_initialize(&vfs_data->files[i]->_lock); fibril_mutex_lock(&vfs_data->files[i]->_lock); vfs_file_addref(vfs_data, vfs_data->files[i]); - + *file = vfs_data->files[i]; vfs_file_addref(vfs_data, *file); - + fibril_mutex_unlock(&vfs_data->lock); *out_fd = (int) i; return EOK; } - + if (desc) { if (i == 0) break; - + i--; } else { if (i == MAX_OPEN_FILES - 1) break; - + i++; } } fibril_mutex_unlock(&vfs_data->lock); - + return EMFILE; } @@ -280,5 +280,5 @@ rc = _vfs_fd_free_locked(vfs_data, fd); fibril_mutex_unlock(&vfs_data->lock); - + return rc; } @@ -319,9 +319,9 @@ (void) _vfs_fd_free_locked(VFS_DATA, fd); assert(FILES[fd] == NULL); - + FILES[fd] = file; vfs_file_addref(VFS_DATA, FILES[fd]); fibril_mutex_unlock(&VFS_DATA->lock); - + return EOK; } @@ -330,5 +330,5 @@ { fibril_mutex_unlock(&file->_lock); - + fibril_mutex_lock(&vfs_data->lock); vfs_file_delref(vfs_data, file); @@ -340,5 +340,5 @@ if (!vfs_files_init(vfs_data)) return NULL; - + fibril_mutex_lock(&vfs_data->lock); if ((fd >= 0) && (fd < MAX_OPEN_FILES)) { @@ -347,5 +347,5 @@ vfs_file_addref(vfs_data, file); fibril_mutex_unlock(&vfs_data->lock); - + fibril_mutex_lock(&file->_lock); if (file->node == NULL) { @@ -359,5 +359,5 @@ } fibril_mutex_unlock(&vfs_data->lock); - + return NULL; } @@ -432,5 +432,5 @@ { vfs_client_data_t *vfs_data = VFS_DATA; - + fibril_mutex_lock(&vfs_data->lock); while (list_empty(&vfs_data->passed_handles)) @@ -449,5 +449,5 @@ return rc; } - + file->node = bh->node; file->permissions = bh->permissions; Index: uspace/srv/vfs/vfs_ipc.c =================================================================== --- uspace/srv/vfs/vfs_ipc.c (revision 1b20da07baaa3e3c424f62c927274e676e4295cd) +++ uspace/srv/vfs/vfs_ipc.c (revision 34e1206ec4dc79f0592077e3ee270fba91d1eb9d) @@ -40,5 +40,5 @@ int newfd = IPC_GET_ARG2(*request); bool desc = IPC_GET_ARG3(*request); - + int outfd = -1; errno_t rc = vfs_op_clone(oldfd, newfd, desc, &outfd); @@ -54,5 +54,5 @@ size_t len; errno_t rc; - + /* * Now we expect the client to send us data with the name of the file @@ -65,10 +65,10 @@ return; } - + rc = vfs_op_fsprobe(fs_name, service_id, &info); async_answer_0(rid, rc); if (rc != EOK) goto out; - + /* Now we should get a read request */ if (!async_data_read_receive(&callid, &len)) @@ -114,5 +114,5 @@ { int mpfd = IPC_GET_ARG1(*request); - + /* * We expect the library to do the device-name to device-handle @@ -121,11 +121,11 @@ */ service_id_t service_id = (service_id_t) IPC_GET_ARG2(*request); - + unsigned int flags = (unsigned int) IPC_GET_ARG3(*request); unsigned int instance = IPC_GET_ARG4(*request); - + char *opts = NULL; char *fs_name = NULL; - + /* Now we expect to receive the mount options. */ errno_t rc = async_data_write_accept((void **) &opts, true, 0, @@ -135,5 +135,5 @@ return; } - + /* Now, we expect the client to send us data with the name of the file * system. @@ -146,10 +146,10 @@ return; } - + int outfd = 0; rc = vfs_op_mount(mpfd, service_id, flags, instance, opts, fs_name, &outfd); async_answer_1(rid, rc, outfd); - + free(opts); free(fs_name); @@ -190,30 +190,30 @@ char *new = NULL; errno_t rc; - + basefd = IPC_GET_ARG1(*request); - + /* Retrieve the old path. */ rc = async_data_write_accept((void **) &old, true, 0, 0, 0, NULL); if (rc != EOK) goto out; - + /* Retrieve the new path. */ rc = async_data_write_accept((void **) &new, true, 0, 0, 0, NULL); if (rc != EOK) goto out; - + size_t olen; size_t nlen; char *oldc = canonify(old, &olen); char *newc = canonify(new, &nlen); - + if ((!oldc) || (!newc)) { rc = EINVAL; goto out; } - + assert(oldc[olen] == '\0'); assert(newc[nlen] == '\0'); - + rc = vfs_op_rename(basefd, oldc, newc); @@ -245,5 +245,5 @@ { int fd = (int) IPC_GET_ARG1(*request); - + errno_t rc = vfs_op_statfs(fd); async_answer_0(rid, rc); @@ -261,10 +261,10 @@ int parentfd = IPC_GET_ARG1(*request); int expectfd = IPC_GET_ARG2(*request); - + char *path; errno_t rc = async_data_write_accept((void **) &path, true, 0, 0, 0, NULL); if (rc == EOK) rc = vfs_op_unlink(parentfd, expectfd, path); - + async_answer_0(rid, rc); } @@ -293,5 +293,5 @@ int parentfd = IPC_GET_ARG1(*request); int flags = IPC_GET_ARG2(*request); - + int fd = 0; char *path; @@ -318,5 +318,5 @@ { bool cont = true; - + /* * The connection was opened via the IPC_CONNECT_ME_TO call. @@ -324,12 +324,12 @@ */ async_answer_0(iid, EOK); - + while (cont) { ipc_call_t call; ipc_callid_t callid = async_get_call(&call); - + if (!IPC_GET_IMETHOD(call)) break; - + switch (IPC_GET_IMETHOD(call)) { case VFS_IN_CLONE: @@ -393,5 +393,5 @@ } } - + /* * Open files for this client will be cleaned up when its last Index: uspace/srv/vfs/vfs_lookup.c =================================================================== --- uspace/srv/vfs/vfs_lookup.c (revision 1b20da07baaa3e3c424f62c927274e676e4295cd) +++ uspace/srv/vfs/vfs_lookup.c (revision 34e1206ec4dc79f0592077e3ee270fba91d1eb9d) @@ -108,5 +108,5 @@ */ list_append(&entry->plb_link, &plb_entries); - + fibril_mutex_unlock(&plb_mutex); @@ -116,5 +116,5 @@ size_t cnt1 = min(len, (PLB_SIZE - first) + 1); size_t cnt2 = len - cnt1; - + memcpy(&plb[first], path, cnt1); memcpy(plb, &path[cnt1], cnt2); @@ -145,9 +145,9 @@ assert(child->fs_handle); assert(path != NULL); - + vfs_lookup_res_t res; char component[NAME_MAX + 1]; errno_t rc; - + size_t len; char *npath = canonify(path, &len); @@ -157,7 +157,7 @@ } path = npath; - + vfs_triplet_t *triplet; - + char *slash = str_rchr(path, L'/'); if (slash && slash != path) { @@ -166,13 +166,13 @@ goto out; } - + memcpy(component, slash + 1, str_size(slash)); *slash = 0; - + rc = vfs_lookup_internal(base, path, L_DIRECTORY, &res); if (rc != EOK) goto out; triplet = &res.triplet; - + *slash = '/'; } else { @@ -181,9 +181,9 @@ goto out; } - + memcpy(component, path + 1, str_size(path)); triplet = (vfs_triplet_t *) base; } - + if (triplet->fs_handle != child->fs_handle || triplet->service_id != child->service_id) { @@ -191,9 +191,9 @@ goto out; } - + async_exch_t *exch = vfs_exchange_grab(triplet->fs_handle); aid_t req = async_send_3(exch, VFS_OUT_LINK, triplet->service_id, triplet->index, child->index, NULL); - + rc = async_data_write_start(exch, component, str_size(component) + 1); errno_t orig_rc; @@ -202,5 +202,5 @@ if (orig_rc != EOK) rc = orig_rc; - + out: return rc; @@ -212,5 +212,5 @@ assert(base); assert(result); - + errno_t rc; ipc_call_t answer; @@ -221,12 +221,12 @@ async_wait_for(req, &rc); vfs_exchange_release(exch); - + if (rc != EOK) return rc; - + unsigned last = *pfirst + *plen; *pfirst = IPC_GET_ARG3(answer) & 0xffff; *plen = last - *pfirst; - + result->triplet.fs_handle = (fs_handle_t) IPC_GET_ARG1(answer); result->triplet.service_id = base->service_id; @@ -248,10 +248,10 @@ if (rc != EOK) return rc; - + size_t next = first; size_t nlen = len; - + vfs_lookup_res_t res; - + /* Resolve path as long as there are mount points to cross. */ while (nlen > 0) { @@ -261,13 +261,13 @@ goto out; } - + base = base->mount; } - + rc = out_lookup((vfs_triplet_t *) base, &next, &nlen, lflag, &res); if (rc != EOK) goto out; - + if (nlen > 0) { base = vfs_node_peek(&res); @@ -288,8 +288,8 @@ } } - + assert(nlen == 0); rc = EOK; - + if (result != NULL) { /* The found file may be a mount point. Try to cross it. */ @@ -303,5 +303,5 @@ base = nbase; } - + result->triplet = *((vfs_triplet_t *) base); result->type = base->type; @@ -316,5 +316,5 @@ *result = res; } - + out: plb_clear_entry(&entry, first, len); @@ -339,5 +339,5 @@ assert(base != NULL); assert(path != NULL); - + size_t len; errno_t rc; @@ -348,5 +348,5 @@ } path = npath; - + assert(path[0] == '/'); @@ -367,5 +367,5 @@ char *slash = str_rchr(path, L'/'); vfs_node_t *parent = base; - + if (slash != path) { int tflag = lflag; @@ -392,5 +392,5 @@ rc = _vfs_lookup_internal(base, path, lflag, result, len); } - + return rc; } Index: uspace/srv/vfs/vfs_node.c =================================================================== --- uspace/srv/vfs/vfs_node.c (revision 1b20da07baaa3e3c424f62c927274e676e4295cd) +++ uspace/srv/vfs/vfs_node.c (revision 34e1206ec4dc79f0592077e3ee270fba91d1eb9d) @@ -108,7 +108,7 @@ { bool free_node = false; - - fibril_mutex_lock(&nodes_mutex); - + + fibril_mutex_lock(&nodes_mutex); + node->refcnt--; if (node->refcnt == 0) { @@ -117,11 +117,11 @@ * Remove it from the VFS node hash table. */ - + hash_table_remove_item(&nodes, &node->nh_link); free_node = true; } - - fibril_mutex_unlock(&nodes_mutex); - + + fibril_mutex_unlock(&nodes_mutex); + if (free_node) { /* @@ -129,5 +129,5 @@ * are no more hard links. */ - + async_exch_t *exch = vfs_exchange_grab(node->fs_handle); async_msg_2(exch, VFS_OUT_DESTROY, (sysarg_t) node->service_id, @@ -239,5 +239,5 @@ (node->service_id == rd->service_id)) rd->refcnt += node->refcnt; - + return true; } @@ -268,14 +268,14 @@ { async_exch_t *exch = vfs_exchange_grab(node->fs_handle); - + ipc_call_t answer; aid_t req = async_send_2(exch, VFS_OUT_OPEN_NODE, (sysarg_t) node->service_id, (sysarg_t) node->index, &answer); - + vfs_exchange_release(exch); errno_t rc; async_wait_for(req, &rc); - + return rc; } @@ -311,5 +311,5 @@ .index = node->index }; - + return tri; } Index: uspace/srv/vfs/vfs_ops.c =================================================================== --- uspace/srv/vfs/vfs_ops.c (revision 1b20da07baaa3e3c424f62c927274e676e4295cd) +++ uspace/srv/vfs/vfs_ops.c (revision 34e1206ec4dc79f0592077e3ee270fba91d1eb9d) @@ -64,11 +64,11 @@ { size_t res = 0; - + while (a[res] == b[res] && a[res] != 0) res++; - + if (a[res] == b[res]) return res; - + res--; while (a[res] != '/') @@ -93,5 +93,5 @@ if (oldfd == newfd) return EOK; - + /* Lookup the file structure corresponding to fd. */ vfs_file_t *oldfile = vfs_file_get(oldfd); @@ -112,10 +112,10 @@ newfile->permissions = oldfile->permissions; vfs_node_addref(newfile->node); - + vfs_file_put(newfile); } } vfs_file_put(oldfile); - + return rc; } @@ -131,12 +131,12 @@ { fs_handle_t fs_handle = 0; - + fibril_mutex_lock(&fs_list_lock); while (true) { fs_handle = fs_name_to_handle(instance, fsname, false); - + if (fs_handle != 0 || !(flags & VFS_MOUNT_BLOCKING)) break; - + fibril_condvar_wait(&fs_list_cv, &fs_list_lock); } @@ -145,5 +145,5 @@ if (fs_handle == 0) return ENOFS; - + /* Tell the mountee that it is being mounted. */ ipc_call_t answer; @@ -164,5 +164,5 @@ return rc; } - + vfs_lookup_res_t res; res.triplet.fs_handle = fs_handle; @@ -172,5 +172,5 @@ IPC_GET_ARG3(answer)); res.type = VFS_NODE_DIRECTORY; - + /* Add reference to the mounted root. */ *root = vfs_node_get(&res); @@ -182,5 +182,5 @@ return ENOMEM; } - + vfs_exchange_release(exch); @@ -194,12 +194,12 @@ errno_t rc; errno_t retval; - + fibril_mutex_lock(&fs_list_lock); fs_handle = fs_name_to_handle(0, fs_name, false); fibril_mutex_unlock(&fs_list_lock); - + if (fs_handle == 0) return ENOFS; - + /* Send probe request to the file system server */ ipc_call_t answer; @@ -209,5 +209,5 @@ if (msg == 0) return EINVAL; - + /* Read probe information */ retval = async_data_read_start(exch, info, sizeof(*info)); @@ -216,5 +216,5 @@ return retval; } - + async_wait_for(msg, &rc); vfs_exchange_release(exch); @@ -229,5 +229,5 @@ vfs_file_t *file = NULL; *out_fd = -1; - + if (!(flags & VFS_MOUNT_CONNECT_ONLY)) { mp = vfs_file_get(mpfd); @@ -236,15 +236,15 @@ goto out; } - + if (mp->node->mount != NULL) { rc = EBUSY; goto out; } - + if (mp->node->type != VFS_NODE_DIRECTORY) { rc = ENOTDIR; goto out; } - + if (vfs_node_has_children(mp->node)) { rc = ENOTEMPTY; @@ -252,5 +252,5 @@ } } - + if (!(flags & VFS_MOUNT_NO_REF)) { rc = vfs_fd_alloc(&file, false, out_fd); @@ -259,7 +259,7 @@ } } - + vfs_node_t *root = NULL; - + fibril_rwlock_write_lock(&namespace_rwlock); @@ -271,15 +271,15 @@ mp->node->mount = root; } - + fibril_rwlock_write_unlock(&namespace_rwlock); - + if (rc != EOK) goto out; - + if (flags & VFS_MOUNT_NO_REF) { vfs_node_delref(root); } else { assert(file != NULL); - + file->node = root; file->permissions = MODE_READ | MODE_WRITE | MODE_APPEND; @@ -287,5 +287,5 @@ file->open_write = false; } - + out: if (mp) @@ -298,5 +298,5 @@ *out_fd = -1; } - + return rc; } @@ -310,24 +310,24 @@ if (!file) return EBADF; - + if ((mode & ~file->permissions) != 0) { vfs_file_put(file); return EPERM; } - + if (file->open_read || file->open_write) { vfs_file_put(file); return EBUSY; } - + file->open_read = (mode & MODE_READ) != 0; file->open_write = (mode & (MODE_WRITE | MODE_APPEND)) != 0; file->append = (mode & MODE_APPEND) != 0; - + if (!file->open_read && !file->open_write) { vfs_file_put(file); return EINVAL; } - + if (file->node->type == VFS_NODE_DIRECTORY && file->open_write) { file->open_read = file->open_write = false; @@ -335,5 +335,5 @@ return EINVAL; } - + errno_t rc = vfs_open_node_remote(file->node); if (rc != EOK) { @@ -342,5 +342,5 @@ return rc; } - + vfs_file_put(file); return EOK; @@ -385,5 +385,5 @@ if (exch == NULL) return ENOENT; - + aid_t msg = async_send_fast(exch, read ? VFS_OUT_READ : VFS_OUT_WRITE, file->node->service_id, file->node->index, LOWER32(pos), @@ -397,8 +397,8 @@ return retval; } - + errno_t rc; async_wait_for(msg, &rc); - + chunk->size = IPC_GET_ARG1(*answer); @@ -418,21 +418,21 @@ * open files supports parallel access! */ - + /* Lookup the file structure corresponding to the file descriptor. */ vfs_file_t *file = vfs_file_get(fd); if (!file) return EBADF; - + if ((read && !file->open_read) || (!read && !file->open_write)) { vfs_file_put(file); return EINVAL; } - + vfs_info_t *fs_info = fs_handle_to_info(file->node->fs_handle); assert(fs_info); - + bool rlock = read || (fs_info->concurrent_read_write && fs_info->write_retains_size); - + /* * Lock the file's node so that no other client can read/write to it at @@ -444,5 +444,5 @@ else fibril_rwlock_write_lock(&file->node->contents_rwlock); - + if (file->node->type == VFS_NODE_DIRECTORY) { /* @@ -450,5 +450,5 @@ * while we are in readdir(). */ - + if (!read) { if (rlock) { @@ -462,13 +462,13 @@ return EINVAL; } - + fibril_rwlock_read_lock(&namespace_rwlock); } - + async_exch_t *fs_exch = vfs_exchange_grab(file->node->fs_handle); - + if (!read && file->append) pos = file->node->size; - + /* * Handle communication with the endpoint FS. @@ -476,10 +476,10 @@ ipc_call_t answer; errno_t rc = ipc_cb(fs_exch, file, pos, &answer, read, ipc_cb_data); - + vfs_exchange_release(fs_exch); - + if (file->node->type == VFS_NODE_DIRECTORY) fibril_rwlock_read_unlock(&namespace_rwlock); - + /* Unlock the VFS node. */ if (rlock) { @@ -493,5 +493,5 @@ fibril_rwlock_write_unlock(&file->node->contents_rwlock); } - + vfs_file_put(file); @@ -518,14 +518,14 @@ vfs_node_addref(base); vfs_file_put(base_file); - + vfs_lookup_res_t base_lr; vfs_lookup_res_t old_lr; vfs_lookup_res_t new_lr_orig; bool orig_unlinked = false; - + errno_t rc; - + size_t shared = shared_path(old, new); - + /* Do not allow one path to be a prefix of the other. */ if (old[shared] == 0 || new[shared] == 0) { @@ -535,7 +535,7 @@ assert(old[shared] == '/'); assert(new[shared] == '/'); - + fibril_rwlock_write_lock(&namespace_rwlock); - + /* Resolve the shared portion of the path first. */ if (shared != 0) { @@ -547,5 +547,5 @@ return rc; } - + vfs_node_put(base); base = vfs_node_get(&base_lr); @@ -565,5 +565,5 @@ return rc; } - + rc = vfs_lookup_internal(base, new, L_UNLINK | L_DISABLE_MOUNTS, &new_lr_orig); @@ -595,5 +595,5 @@ return rc; } - + /* If the node is not held by anyone, try to destroy it. */ if (orig_unlinked) { @@ -604,5 +604,5 @@ vfs_node_put(node); } - + vfs_node_put(base); fibril_rwlock_write_unlock(&namespace_rwlock); @@ -617,10 +617,10 @@ fibril_rwlock_write_lock(&file->node->contents_rwlock); - + errno_t rc = vfs_truncate_internal(file->node->fs_handle, file->node->service_id, file->node->index, size); if (rc == EOK) file->node->size = size; - + fibril_rwlock_write_unlock(&file->node->contents_rwlock); vfs_file_put(file); @@ -640,5 +640,5 @@ node->service_id, node->index, true, 0, NULL); vfs_exchange_release(exch); - + vfs_file_put(file); return rc; @@ -667,20 +667,20 @@ if (!file) return EBADF; - + async_exch_t *fs_exch = vfs_exchange_grab(file->node->fs_handle); - + aid_t msg; ipc_call_t answer; msg = async_send_2(fs_exch, VFS_OUT_SYNC, file->node->service_id, file->node->index, &answer); - + vfs_exchange_release(fs_exch); - + errno_t rc; async_wait_for(msg, &rc); - + vfs_file_put(file); return rc; - + } @@ -693,5 +693,5 @@ UPPER32(size)); vfs_exchange_release(exch); - + return (errno_t) rc; } @@ -702,10 +702,10 @@ vfs_file_t *parent = NULL; vfs_file_t *expect = NULL; - + if (parentfd == expectfd) return EINVAL; - + fibril_rwlock_write_lock(&namespace_rwlock); - + /* * Files are retrieved in order of file descriptors, to prevent @@ -719,5 +719,5 @@ } } - + if (expectfd >= 0) { expect = vfs_file_get(expectfd); @@ -727,5 +727,5 @@ } } - + if (parentfd > expectfd) { parent = vfs_file_get(parentfd); @@ -735,7 +735,7 @@ } } - + assert(parent != NULL); - + if (expectfd >= 0) { vfs_lookup_res_t lr; @@ -743,5 +743,5 @@ if (rc != EOK) goto exit; - + vfs_node_t *found_node = vfs_node_peek(&lr); vfs_node_put(found_node); @@ -750,9 +750,9 @@ goto exit; } - + vfs_file_put(expect); expect = NULL; } - + vfs_lookup_res_t lr; rc = vfs_lookup_internal(parent->node, path, L_UNLINK, &lr); @@ -783,12 +783,12 @@ if (mp == NULL) return EBADF; - + if (mp->node->mount == NULL) { vfs_file_put(mp); return ENOENT; } - + fibril_rwlock_write_lock(&namespace_rwlock); - + /* * Count the total number of references for the mounted file system. We @@ -804,10 +804,10 @@ return EBUSY; } - + async_exch_t *exch = vfs_exchange_grab(mp->node->mount->fs_handle); errno_t rc = async_req_1_0(exch, VFS_OUT_UNMOUNTED, mp->node->mount->service_id); vfs_exchange_release(exch); - + if (rc != EOK) { vfs_file_put(mp); @@ -815,11 +815,11 @@ return rc; } - + vfs_node_forget(mp->node->mount); vfs_node_put(mp->node); mp->node->mount = NULL; - + fibril_rwlock_write_unlock(&namespace_rwlock); - + vfs_file_put(mp); return EOK; @@ -866,11 +866,11 @@ if (!walk_flags_valid(flags)) return EINVAL; - + vfs_file_t *parent = vfs_file_get(parentfd); if (!parent) return EBADF; - + fibril_rwlock_read_lock(&namespace_rwlock); - + vfs_lookup_res_t lr; errno_t rc = vfs_lookup_internal(parent->node, path, @@ -881,5 +881,5 @@ return rc; } - + vfs_node_t *node = vfs_node_get(&lr); if (!node) { @@ -888,5 +888,5 @@ return ENOMEM; } - + vfs_file_t *file; rc = vfs_fd_alloc(&file, false, out_fd); @@ -897,13 +897,13 @@ } assert(file != NULL); - + file->node = node; file->permissions = parent->permissions; file->open_read = false; file->open_write = false; - + vfs_file_put(file); vfs_file_put(parent); - + fibril_rwlock_read_unlock(&namespace_rwlock); Index: uspace/srv/vfs/vfs_register.c =================================================================== --- uspace/srv/vfs/vfs_register.c (revision 1b20da07baaa3e3c424f62c927274e676e4295cd) +++ uspace/srv/vfs/vfs_register.c (revision 34e1206ec4dc79f0592077e3ee270fba91d1eb9d) @@ -71,5 +71,5 @@ { int i; - + /* * Check if the name is non-empty and is composed solely of ASCII @@ -80,5 +80,5 @@ return false; } - + for (i = 1; i < FS_NAME_MAXLEN; i++) { if (!(islower(info->name[i]) || isdigit(info->name[i])) && @@ -93,5 +93,5 @@ } } - + /* * This check is not redundant. It ensures that the name is @@ -102,5 +102,5 @@ return false; } - + return true; } @@ -116,9 +116,9 @@ dprintf("Processing VFS_REGISTER request received from %zx.\n", request->in_phone_hash); - + vfs_info_t *vfs_info; errno_t rc = async_data_write_accept((void **) &vfs_info, false, sizeof(vfs_info_t), sizeof(vfs_info_t), 0, NULL); - + if (rc != EOK) { dprintf("Failed to deliver the VFS info into our AS, rc=%d.\n", @@ -127,5 +127,5 @@ return; } - + /* * Allocate and initialize a buffer for the fs_info structure. @@ -137,11 +137,11 @@ return; } - + link_initialize(&fs_info->fs_link); fs_info->vfs_info = *vfs_info; free(vfs_info); - + dprintf("VFS info delivered.\n"); - + if (!vfs_info_sane(&fs_info->vfs_info)) { free(fs_info); @@ -149,7 +149,7 @@ return; } - + fibril_mutex_lock(&fs_list_lock); - + /* * Check for duplicit registrations. @@ -166,5 +166,5 @@ return; } - + /* * Add fs_info to the list of registered FS's. @@ -172,5 +172,5 @@ dprintf("Inserting FS into the list of registered file systems.\n"); list_append(&fs_info->fs_link, &fs_list); - + /* * Now we want the client to send us the IPC_M_CONNECT_TO_ME call so @@ -187,11 +187,11 @@ return; } - + dprintf("Callback connection to FS created.\n"); - + /* * The client will want us to send him the address space area with PLB. */ - + size_t size; ipc_callid_t callid; @@ -206,5 +206,5 @@ return; } - + /* * We can only send the client address space area PLB_SIZE bytes long. @@ -220,5 +220,5 @@ return; } - + /* * Commit to read-only sharing the PLB with the client. @@ -226,7 +226,7 @@ (void) async_share_in_finalize(callid, plb, AS_AREA_READ | AS_AREA_CACHEABLE); - + dprintf("Sharing PLB.\n"); - + /* * That was it. The FS has been registered. @@ -236,8 +236,8 @@ fs_info->fs_handle = (fs_handle_t) atomic_postinc(&fs_handle_next); async_answer_1(rid, EOK, (sysarg_t) fs_info->fs_handle); - + fibril_condvar_broadcast(&fs_list_cv); fibril_mutex_unlock(&fs_list_lock); - + dprintf("\"%.*s\" filesystem successfully registered, handle=%d.\n", FS_NAME_MAXLEN, fs_info->vfs_info.name, fs_info->fs_handle); @@ -260,19 +260,19 @@ */ fibril_mutex_lock(&fs_list_lock); - + list_foreach(fs_list, fs_link, fs_info_t, fs) { if (fs->fs_handle == handle) { fibril_mutex_unlock(&fs_list_lock); - + assert(fs->sess); async_exch_t *exch = async_exchange_begin(fs->sess); - + assert(exch); return exch; } } - + fibril_mutex_unlock(&fs_list_lock); - + return NULL; } @@ -300,8 +300,8 @@ { int handle = 0; - + if (lock) fibril_mutex_lock(&fs_list_lock); - + list_foreach(fs_list, fs_link, fs_info_t, fs) { if (str_cmp(fs->vfs_info.name, name) == 0 && @@ -311,8 +311,8 @@ } } - + if (lock) fibril_mutex_unlock(&fs_list_lock); - + return handle; } @@ -328,5 +328,5 @@ { vfs_info_t *info = NULL; - + fibril_mutex_lock(&fs_list_lock); list_foreach(fs_list, fs_link, fs_info_t, fs) { @@ -337,5 +337,5 @@ } fibril_mutex_unlock(&fs_list_lock); - + return info; } @@ -355,5 +355,5 @@ fibril_mutex_lock(&fs_list_lock); - + size = 0; count = 0; @@ -362,8 +362,8 @@ count++; } - + if (size == 0) size = 1; - + fstypes->buf = calloc(1, size); if (fstypes->buf == NULL) { @@ -371,5 +371,5 @@ return ENOMEM; } - + fstypes->fstypes = calloc(sizeof(char *), count); if (fstypes->fstypes == NULL) { @@ -379,7 +379,7 @@ return ENOMEM; } - + fstypes->size = size; - + size = 0; count = 0; list_foreach(fs_list, fs_link, fs_info_t, fs) {