Changeset 80e9e5e in mainline for uspace/lib

Timestamp:

2011-07-27T01:54:34Z (14 years ago)

Author:

Petr Koupy <petr.koupy@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

0837ab4

Parents:

c936c7f (diff), 75aa59a (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge mainline changes.

Location:

uspace/lib

Files:

• block/libblock.c (modified) (11 diffs)
• c/generic/elf/elf_load.c (modified) (6 diffs)
• c/generic/vfs/vfs.c (modified) (1 diff)
• c/include/unistd.h (modified) (1 diff)
• fs/libfs.c (modified) (19 diffs)
• fs/libfs.h (modified) (3 diffs)
• scsi/include/scsi/sbc.h (modified) (2 diffs)
• scsi/include/scsi/spc.h (modified) (2 diffs)
• scsi/src/spc.c (modified) (2 diffs)

uspace/lib/block/libblock.c

@@ -258 +258 @@
 static hash_index_t cache_hash(unsigned long *key)
 {
-        return *key & (CACHE_BUCKETS - 1);
+        return MERGE_LOUP32(key[0], key[1]) & (CACHE_BUCKETS - 1);
 }
 
@@ -264 +264 @@
 {
         block_t *b = hash_table_get_instance(item, block_t, hash_link);
-        return b->lba == *key;
+        return b->lba == MERGE_LOUP32(key[0], key[1]);
 }
 
@@ -305 +305 @@
         cache->blocks_cluster = cache->lblock_size / devcon->pblock_size;
 
-        if (!hash_table_create(&cache->block_hash, CACHE_BUCKETS, 1,
+        if (!hash_table_create(&cache->block_hash, CACHE_BUCKETS, 2,
             &cache_ops)) {
                 free(cache);
@@ -344 +344 @@
                 }
 
-                unsigned long key = b->lba;
-                hash_table_remove(&cache->block_hash, &key, 1);
+                unsigned long key[2] = {
+                        LOWER32(b->lba),
+                        UPPER32(b->lba)
+                };
+                hash_table_remove(&cache->block_hash, key, 2);
                 
                 free(b->data);
@@ -398 +401 @@
         block_t *b;
         link_t *l;
-        unsigned long key = ba;
+        unsigned long key[2] = {
+                LOWER32(ba),
+                UPPER32(ba)
+        };
+
         int rc;
         
@@ -413 +420 @@
 
         fibril_mutex_lock(&cache->lock);
-        l = hash_table_find(&cache->block_hash, &key);
+        l = hash_table_find(&cache->block_hash, key);
         if (l) {
 found:
@@ -451 +458 @@
                          * Try to recycle a block from the free list.
                          */
-                        unsigned long temp_key;
 recycle:
                         if (list_empty(&cache->free_list)) {
@@ -499 +505 @@
                                         goto retry;
                                 }
-                                l = hash_table_find(&cache->block_hash, &key);
+                                l = hash_table_find(&cache->block_hash, key);
                                 if (l) {
                                         /*
@@ -522 +528 @@
                          */
                         list_remove(&b->free_link);
-                        temp_key = b->lba;
-                        hash_table_remove(&cache->block_hash, &temp_key, 1);
+                        unsigned long temp_key[2] = {
+                                LOWER32(b->lba),
+                                UPPER32(b->lba)
+                        };
+                        hash_table_remove(&cache->block_hash, temp_key, 2);
                 }
 
@@ -531 +540 @@
                 b->lba = ba;
                 b->pba = ba_ltop(devcon, b->lba);
-                hash_table_insert(&cache->block_hash, &key, &b->hash_link);
+                hash_table_insert(&cache->block_hash, key, &b->hash_link);
 
                 /*
@@ -643 +652 @@
                          * Take the block out of the cache and free it.
                          */
-                        unsigned long key = block->lba;
-                        hash_table_remove(&cache->block_hash, &key, 1);
+                        unsigned long key[2] = {
+                                LOWER32(block->lba),
+                                UPPER32(block->lba)
+                        };
+                        hash_table_remove(&cache->block_hash, key, 2);
                         fibril_mutex_unlock(&block->lock);
                         free(block->data);

uspace/lib/c/generic/elf/elf_load.c

@@ -74 +74 @@
 static int load_segment(elf_ld_t *elf, elf_segment_header_t *entry);
 
-/** Read until the buffer is read in its entirety. */
-static int my_read(int fd, void *buf, size_t len)
-{
-        int cnt = 0;
-        do {
-                buf += cnt;
-                len -= cnt;
-                cnt = read(fd, buf, len);
-        } while ((cnt > 0) && ((len - cnt) > 0));
-
-        return cnt;
-}
-
 /** Load ELF binary from a file.
  *
@@ -160 +147 @@
         int i, rc;
 
-        rc = my_read(elf->fd, header, sizeof(elf_header_t));
-        if (rc < 0) {
+        rc = read_all(elf->fd, header, sizeof(elf_header_t));
+        if (rc != sizeof(elf_header_t)) {
                 DPRINTF("Read error.\n"); 
                 return EE_INVALID;
@@ -222 +209 @@
                         + i * sizeof(elf_segment_header_t), SEEK_SET);
 
-                rc = my_read(elf->fd, &segment_hdr,
+                rc = read_all(elf->fd, &segment_hdr,
                     sizeof(elf_segment_header_t));
-                if (rc < 0) {
+                if (rc != sizeof(elf_segment_header_t)) {
                         DPRINTF("Read error.\n");
                         return EE_INVALID;
@@ -244 +231 @@
                     + i * sizeof(elf_section_header_t), SEEK_SET);
 
-                rc = my_read(elf->fd, &section_hdr,
+                rc = read_all(elf->fd, &section_hdr,
                     sizeof(elf_section_header_t));
-                if (rc < 0) {
+                if (rc != sizeof(elf_section_header_t)) {
                         DPRINTF("Read error.\n");
                         return EE_INVALID;
@@ -334 +321 @@
         uintptr_t seg_addr;
         size_t mem_sz;
-        int rc;
+        ssize_t rc;
 
         bias = elf->bias;
@@ -412 +399 @@
                 if (now > left) now = left;
 
-                rc = my_read(elf->fd, dp, now);
-
-                if (rc < 0) { 
+                rc = read_all(elf->fd, dp, now);
+
+                if (rc != (ssize_t) now) { 
                         DPRINTF("Read error.\n");
                         return EE_INVALID;

uspace/lib/c/generic/vfs/vfs.c

@@ -417 +417 @@
 }
 
+/** Read entire buffer.
+ *
+ * In face of short reads this function continues reading until either
+ * the entire buffer is read or no more data is available (at end of file).
+ *
+ * @param fildes        File descriptor
+ * @param buf           Buffer, @a nbytes bytes long
+ * @param nbytes        Number of bytes to read
+ *
+ * @return              On success, positive number of bytes read.
+ *                      On failure, negative error code from read().
+ */
+ssize_t read_all(int fildes, void *buf, size_t nbyte)
+{
+        ssize_t cnt = 0;
+        size_t nread = 0;
+        uint8_t *bp = (uint8_t *) buf;
+
+        do {
+                bp += cnt;
+                nread += cnt;
+                cnt = read(fildes, bp, nbyte - nread);
+        } while (cnt > 0 && (nbyte - nread - cnt) > 0);
+
+        if (cnt < 0)
+                return cnt;
+
+        return nread + cnt;
+}
+
+/** Write entire buffer.
+ *
+ * This function fails if it cannot write exactly @a len bytes to the file.
+ *
+ * @param fildes        File descriptor
+ * @param buf           Data, @a nbytes bytes long
+ * @param nbytes        Number of bytes to write
+ *
+ * @return              EOK on error, return value from write() if writing
+ *                      failed.
+ */
+ssize_t write_all(int fildes, const void *buf, size_t nbyte)
+{
+        ssize_t cnt = 0;
+        ssize_t nwritten = 0;
+        const uint8_t *bp = (uint8_t *) buf;
+
+        do {
+                bp += cnt;
+                nwritten += cnt;
+                cnt = write(fildes, bp, nbyte - nwritten);
+        } while (cnt > 0 && ((ssize_t )nbyte - nwritten - cnt) > 0);
+
+        if (cnt < 0)
+                return cnt;
+
+        if ((ssize_t)nbyte - nwritten - cnt > 0)
+                return EIO;
+
+        return nbyte;
+}
+
 int fsync(int fildes)
 {

uspace/lib/c/include/unistd.h

@@ -63 +63 @@
 extern ssize_t read(int, void *, size_t);
 
+extern ssize_t read_all(int, void *, size_t);
+extern ssize_t write_all(int, const void *, size_t);
+
 extern off64_t lseek(int, off64_t, int);
 extern int ftruncate(int, aoff64_t);

uspace/lib/fs/libfs.c

@@ -45 +45 @@
 #include <mem.h>
 #include <sys/stat.h>
+#include <stdlib.h>
 
 #define on_error(rc, action) \
@@ -61 +62 @@
         } 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)
+                async_answer_4(rid, EOK, index, LOWER32(size), UPPER32(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)
+                async_answer_3(rid, EOK, wbytes, LOWER32(nsize), UPPER32(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 +291 @@
  *
  * @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 +325 @@
         
         /*
+         * 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 +348 @@
          * 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 +361 @@
          */
         async_wait_for(req, NULL);
-        reg->fs_handle = (int) IPC_GET_ARG1(answer);
+        reg.fs_handle = (int) IPC_GET_ARG1(answer);
         
         /*
@@ -140 +367 @@
          * the same connection fibril as well.
          */
-        async_set_client_connection(conn);
+        async_set_client_connection(vfs_connection);
         
         return IPC_GET_RETVAL(answer);
@@ -151 +378 @@
 
 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);
@@ -208 +435 @@
          * Do not release the FS node so that it stays in memory.
          */
-        async_answer_3(rid, rc, IPC_GET_ARG1(answer), IPC_GET_ARG2(answer),
-            IPC_GET_ARG3(answer));
-}
-
-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);
+        async_answer_4(rid, rc, IPC_GET_ARG1(answer), IPC_GET_ARG2(answer),
+            IPC_GET_ARG3(answer), IPC_GET_ARG4(answer));
+}
+
+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 +486 @@
 }
 
+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 +505 @@
  */
 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 +530 @@
                 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 +539 @@
         
         /* Eat slash */
-        if (ops->plb_get_char(next) == '/')
+        if (plb_get_char(next) == '/')
                 next++;
         
@@ -319 +552 @@
                 /* 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 +558 @@
                                 goto out;
                         }
-                        component[len++] = ops->plb_get_char(next);
+                        component[len++] = plb_get_char(next);
                         /* Process next character */
                         next++;
@@ -357 +590 @@
                         
                         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 +684 @@
                         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 +696 @@
                                 }
                                 
-                                component[len++] = ops->plb_get_char(next);
+                                component[len++] = plb_get_char(next);
                                 /* Process next character */
                                 next++;
@@ -637 +870 @@
         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));
         

uspace/lib/fs/libfs.h

@@ -43 +43 @@
 
 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 +84 @@
         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 +100 @@
 } 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

uspace/lib/scsi/include/scsi/sbc.h

@@ -56 +56 @@
 };
 
+/** SCSI Read (10) command */
+typedef struct {
+        /** Operation code (SCSI_CMD_READ_10) */
+        uint8_t op_code;
+        /** RdProtect, DPO, FUA, Reserved, FUA_NV, Obsolete */
+        uint8_t flags;
+        /** Logical block address */
+        uint32_t lba;
+        /** Reserved, Group Number */
+        uint8_t group_no;
+        /** Transfer length */
+        uint16_t xfer_len;
+        /** Control */
+        uint8_t control;
+} __attribute__((packed)) scsi_cdb_read_10_t;
+
 /** SCSI Read (12) command */
 typedef struct {
         /** Operation code (SCSI_CMD_READ_12) */
         uint8_t op_code;
-        /** RdProtect, DPO, FUA, Reserved, FUA_NV, Reserved */
+        /** RdProtect, DPO, FUA, Reserved, FUA_NV, Obsolete */
         uint8_t flags;
         /** Logical block address */
@@ -115 +131 @@
 } scsi_read_capacity_10_data_t;
 
+/** SCSI Write (10) command */
+typedef struct {
+        /** Operation code (SCSI_CMD_WRITE_10) */
+        uint8_t op_code;
+        /** WrProtect, DPO, FUA, Reserved, FUA_NV, Obsolete */
+        uint8_t flags;
+        /** Logical block address */
+        uint32_t lba;
+        /** Reserved, Group Number */
+        uint8_t group_no;
+        /** Transfer length */
+        uint16_t xfer_len;
+        /** Control */
+        uint8_t control;
+} __attribute__((packed)) scsi_cdb_write_10_t;
+
 /** SCSI Write (12) command */
 typedef struct {
         /** Operation code (SCSI_CMD_WRITE_12) */
         uint8_t op_code;
-        /** WrProtect, DPO, FUA, Reserved, FUA_NV, Reserved */
+        /** WrProtect, DPO, FUA, Reserved, FUA_NV, Obsolete */
         uint8_t flags;
         /** Logical block address */

uspace/lib/scsi/include/scsi/spc.h

@@ -179 +179 @@
         uint8_t additional_len;
         /** Command-specific Information */
-        uint8_t cmd_spec;
+        uint32_t cmd_spec;
         /** Additional Sense Code */
         uint8_t additional_code;
@@ -205 +205 @@
         SCSI_SK_ABORTED_COMMAND = 0xb,
         SCSI_SK_VOLUME_OVERFLOW = 0xd,
-        SCSI_SK_MISCOMPARE      = 0xe
+        SCSI_SK_MISCOMPARE      = 0xe,
+
+        SCSI_SK_LIMIT           = 0x10
 };
 
 extern const char *scsi_dev_type_str[SCSI_DEV_LIMIT];
+extern const char *scsi_sense_key_str[SCSI_SK_LIMIT];
+
 extern const char *scsi_get_dev_type_str(unsigned);
+extern const char *scsi_get_sense_key_str(unsigned);
 
 #endif

uspace/lib/scsi/src/spc.c

@@ -44 +44 @@
 };
 
+const char *scsi_sense_key_str[SCSI_SK_LIMIT] = {
+        [SCSI_SK_NO_SENSE]              = "No Sense",
+        [SCSI_SK_RECOVERED_ERROR]       = "Recovered Error",
+        [SCSI_SK_NOT_READY]             = "Not Ready",
+        [SCSI_SK_MEDIUM_ERROR]          = "Medium Error",
+        [SCSI_SK_HARDWARE_ERROR]        = "Hardware Error",
+        [SCSI_SK_ILLEGAL_REQUEST]       = "Illegal Request",
+        [SCSI_SK_UNIT_ATTENTION]        = "Unit Attention",
+        [SCSI_SK_DATA_PROTECT]          = "Data Protect",
+        [SCSI_SK_BLANK_CHECK]           = "Blank Check",
+        [SCSI_SK_VENDOR_SPECIFIC]       = "Vendor-specific",
+        [SCSI_SK_COPY_ABORTED]          = "Copy Aborted",
+        [SCSI_SK_ABORTED_COMMAND]       = "Aborted Command",
+        [SCSI_SK_VOLUME_OVERFLOW]       = "Volume Overflow",
+        [SCSI_SK_MISCOMPARE]            = "Miscompare"
+};
+
 /** Get peripheral device type string.
  *
@@ -53 +70 @@
 {
         if (dev_type >= SCSI_DEV_LIMIT || scsi_dev_type_str[dev_type] == NULL)
-                return "<unknown>";
+                return "Unknown";
 
         return scsi_dev_type_str[dev_type];
 }
+
+/** Get sense key string.
+ *
+ * Return string description of SCSI sense key.
+ * The returned string is valid indefinitely, the caller should
+ * not attempt to free it.
+ */
+const char *scsi_get_sense_key_str(unsigned sense_key)
+{
+        if (sense_key >= SCSI_SK_LIMIT || scsi_sense_key_str[sense_key] == NULL)
+                return "Unknown";
+
+        return scsi_sense_key_str[sense_key];
+}
+