Changeset 16dc887 in mainline for uspace/srv/vfs

Timestamp:

2011-08-16T14:00:32Z (14 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

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

Children:

278ac72, b112055

Parents:

3751a08 (diff), cc574511 (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 Location service.

Location:

uspace/srv/vfs

Files:

• vfs.h (modified) (4 diffs)
• vfs_file.c (modified) (1 diff)
• vfs_lookup.c (modified) (3 diffs)
• vfs_node.c (modified) (8 diffs)
• vfs_ops.c (modified) (26 diffs)
• vfs_register.c (modified) (1 diff)

uspace/srv/vfs/vfs.h

@@ -38 +38 @@
 #include <fibril_synch.h>
 #include <sys/types.h>
-#include <devmap.h>
+#include <loc.h>
 #include <bool.h>
 #include <ipc/vfs.h>
@@ -61 +61 @@
 #define VFS_PAIR \
         fs_handle_t fs_handle; \
-        devmap_handle_t devmap_handle;
+        service_id_t service_id;
 
 /**
@@ -67 +67 @@
  * doesn't contain any state. For a stateful structure, see vfs_node_t.
  *
- * @note        fs_handle, devmap_handle and index are meant to be returned in one
+ * @note        fs_handle, service_id and index are meant to be returned in one
  *              IPC reply.
  */
@@ -181 +181 @@
 extern void vfs_node_put(vfs_node_t *);
 extern void vfs_node_forget(vfs_node_t *);
-extern unsigned vfs_nodes_refcount_sum_get(fs_handle_t, devmap_handle_t);
+extern unsigned vfs_nodes_refcount_sum_get(fs_handle_t, service_id_t);
 
 

uspace/srv/vfs/vfs_file.c

@@ -115 +115 @@
         
         ipc_call_t answer;
-        aid_t msg = async_send_2(exch, VFS_OUT_CLOSE, file->node->devmap_handle,
+        aid_t msg = async_send_2(exch, VFS_OUT_CLOSE, file->node->service_id,
             file->node->index, &answer);
         

uspace/srv/vfs/vfs_lookup.c

@@ -162 +162 @@
         aid_t req = async_send_5(exch, VFS_OUT_LOOKUP, (sysarg_t) first,
             (sysarg_t) (first + len - 1) % PLB_SIZE,
-            (sysarg_t) root->devmap_handle, (sysarg_t) lflag, (sysarg_t) index,
+            (sysarg_t) root->service_id, (sysarg_t) lflag, (sysarg_t) index,
             &answer);
         
@@ -185 +185 @@
         
         result->triplet.fs_handle = (fs_handle_t) rc;
-        result->triplet.devmap_handle = (devmap_handle_t) IPC_GET_ARG1(answer);
+        result->triplet.service_id = (service_id_t) IPC_GET_ARG1(answer);
         result->triplet.index = (fs_index_t) IPC_GET_ARG2(answer);
         result->size =
@@ -212 +212 @@
         ipc_call_t answer;
         aid_t req = async_send_2(exch, VFS_OUT_OPEN_NODE,
-            (sysarg_t) result->triplet.devmap_handle,
+            (sysarg_t) result->triplet.service_id,
             (sysarg_t) result->triplet.index, &answer);
         

uspace/srv/vfs/vfs_node.c

@@ -116 +116 @@
                 unsigned long key[] = {
                         [KEY_FS_HANDLE] = node->fs_handle,
-                        [KEY_DEV_HANDLE] = node->devmap_handle,
+                        [KEY_DEV_HANDLE] = node->service_id,
                         [KEY_INDEX] = node->index
                 };
@@ -138 +138 @@
                 async_exch_t *exch = vfs_exchange_grab(node->fs_handle);
                 sysarg_t rc = async_req_2_0(exch, VFS_OUT_DESTROY,
-                    (sysarg_t) node->devmap_handle, (sysarg_t)node->index);
+                    (sysarg_t) node->service_id, (sysarg_t)node->index);
                 
                 assert(rc == EOK);
@@ -160 +160 @@
         unsigned long key[] = {
                 [KEY_FS_HANDLE] = node->fs_handle,
-                [KEY_DEV_HANDLE] = node->devmap_handle,
+                [KEY_DEV_HANDLE] = node->service_id,
                 [KEY_INDEX] = node->index
         };
@@ -184 +184 @@
         unsigned long key[] = {
                 [KEY_FS_HANDLE] = result->triplet.fs_handle,
-                [KEY_DEV_HANDLE] = result->triplet.devmap_handle,
+                [KEY_DEV_HANDLE] = result->triplet.service_id,
                 [KEY_INDEX] = result->triplet.index
         };
@@ -200 +200 @@
                 memset(node, 0, sizeof(vfs_node_t));
                 node->fs_handle = result->triplet.fs_handle;
-                node->devmap_handle = result->triplet.devmap_handle;
+                node->service_id = result->triplet.service_id;
                 node->index = result->triplet.index;
                 node->size = result->size;
@@ -252 +252 @@
         vfs_node_t *node = hash_table_get_instance(item, vfs_node_t, nh_link);
         return (node->fs_handle == (fs_handle_t) key[KEY_FS_HANDLE]) &&
-            (node->devmap_handle == key[KEY_DEV_HANDLE]) &&
+            (node->service_id == key[KEY_DEV_HANDLE]) &&
             (node->index == key[KEY_INDEX]);
 }
@@ -264 +264 @@
         unsigned refcnt;
         fs_handle_t fs_handle;
-        devmap_handle_t devmap_handle;
+        service_id_t service_id;
 };
 
@@ -273 +273 @@
 
         if ((node->fs_handle == rd->fs_handle) &&
-            (node->devmap_handle == rd->devmap_handle))
+            (node->service_id == rd->service_id))
                 rd->refcnt += node->refcnt;
 }
 
 unsigned
-vfs_nodes_refcount_sum_get(fs_handle_t fs_handle, devmap_handle_t devmap_handle)
+vfs_nodes_refcount_sum_get(fs_handle_t fs_handle, service_id_t service_id)
 {
         struct refcnt_data rd = {
                 .refcnt = 0,
                 .fs_handle = fs_handle,
-                .devmap_handle = devmap_handle
+                .service_id = service_id
         };
 

uspace/srv/vfs/vfs_ops.c

@@ -54 +54 @@
 
 /* Forward declarations of static functions. */
-static int vfs_truncate_internal(fs_handle_t, devmap_handle_t, fs_index_t,
+static int vfs_truncate_internal(fs_handle_t, service_id_t, fs_index_t,
     aoff64_t);
 
@@ -65 +65 @@
 vfs_pair_t rootfs = {
         .fs_handle = 0,
-        .devmap_handle = 0
+        .service_id = 0
 };
 
-static void vfs_mount_internal(ipc_callid_t rid, devmap_handle_t devmap_handle,
+static void vfs_mount_internal(ipc_callid_t rid, service_id_t service_id,
     fs_handle_t fs_handle, char *mp, char *opts)
 {
@@ -125 +125 @@
                         exch = vfs_exchange_grab(fs_handle);
                         msg = async_send_1(exch, VFS_OUT_MOUNTED,
-                            (sysarg_t) devmap_handle, &answer);
+                            (sysarg_t) service_id, &answer);
                         /* Send the mount options */
                         rc = async_data_write_start(exch, (void *)opts,
@@ -150 +150 @@
                         
                         mr_res.triplet.fs_handle = fs_handle;
-                        mr_res.triplet.devmap_handle = devmap_handle;
+                        mr_res.triplet.service_id = service_id;
                         mr_res.triplet.index = rindex;
                         mr_res.size = rsize;
@@ -157 +157 @@
                         
                         rootfs.fs_handle = fs_handle;
-                        rootfs.devmap_handle = devmap_handle;
+                        rootfs.service_id = service_id;
                         
                         /* Add reference to the mounted root. */
@@ -178 +178 @@
         
         /*
-         * At this point, we have all necessary pieces: file system and device
-         * handles, and we know the mount point VFS node.
+         * At this point, we have all necessary pieces: file system handle
+         * and service ID, and we know the mount point VFS node.
          */
         
@@ -187 +187 @@
         exch = vfs_exchange_grab(mp_res.triplet.fs_handle);
         msg = async_send_4(exch, VFS_OUT_MOUNT,
-            (sysarg_t) mp_res.triplet.devmap_handle,
+            (sysarg_t) mp_res.triplet.service_id,
             (sysarg_t) mp_res.triplet.index,
             (sysarg_t) fs_handle,
-            (sysarg_t) devmap_handle, &answer);
+            (sysarg_t) service_id, &answer);
         
         /* Send connection */
@@ -234 +234 @@
                 
                 mr_res.triplet.fs_handle = fs_handle;
-                mr_res.triplet.devmap_handle = devmap_handle;
+                mr_res.triplet.service_id = service_id;
                 mr_res.triplet.index = rindex;
                 mr_res.size = rsize;
@@ -255 +255 @@
 void vfs_mount(ipc_callid_t rid, ipc_call_t *request)
 {
-        devmap_handle_t devmap_handle;
+        service_id_t service_id;
 
         /*
@@ -262 +262 @@
          * in the request.
          */
-        devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
+        service_id = (service_id_t) IPC_GET_ARG1(*request);
         
         /*
@@ -350 +350 @@
         
         /* Do the mount */
-        vfs_mount_internal(rid, devmap_handle, fs_handle, mp, opts);
+        vfs_mount_internal(rid, service_id, fs_handle, mp, opts);
         free(mp);
         free(fs_name);
@@ -409 +409 @@
          */
         if (vfs_nodes_refcount_sum_get(mr_node->fs_handle,
-            mr_node->devmap_handle) != 2) {
+            mr_node->service_id) != 2) {
                 fibril_rwlock_write_unlock(&namespace_rwlock);
                 vfs_node_put(mr_node);
@@ -430 +430 @@
                 exch = vfs_exchange_grab(mr_node->fs_handle);
                 rc = async_req_1_0(exch, VFS_OUT_UNMOUNTED,
-                    mr_node->devmap_handle);
+                    mr_node->service_id);
                 vfs_exchange_release(exch);
                 
@@ -441 +441 @@
                 
                 rootfs.fs_handle = 0;
-                rootfs.devmap_handle = 0;
+                rootfs.service_id = 0;
         } else {
                 
@@ -470 +470 @@
                 exch = vfs_exchange_grab(mp_node->fs_handle);
                 rc = async_req_2_0(exch, VFS_OUT_UNMOUNT,
-                    mp_node->devmap_handle, mp_node->index);
+                    mp_node->service_id, mp_node->index);
                 vfs_exchange_release(exch);
                 
@@ -575 +575 @@
                 if (node->size) {
                         rc = vfs_truncate_internal(node->fs_handle,
-                            node->devmap_handle, node->index, 0);
+                            node->service_id, node->index, 0);
                         if (rc) {
                                 fibril_rwlock_write_unlock(&node->contents_rwlock);
@@ -628 +628 @@
         
         lr.triplet.fs_handle = IPC_GET_ARG1(*request);
-        lr.triplet.devmap_handle = IPC_GET_ARG2(*request);
+        lr.triplet.service_id = IPC_GET_ARG2(*request);
         lr.triplet.index = IPC_GET_ARG3(*request);
         int oflag = IPC_GET_ARG4(*request);
@@ -649 +649 @@
                 if (node->size) {
                         rc = vfs_truncate_internal(node->fs_handle,
-                            node->devmap_handle, node->index, 0);
+                            node->service_id, node->index, 0);
                         if (rc) {
                                 fibril_rwlock_write_unlock(&node->contents_rwlock);
@@ -712 +712 @@
         aid_t msg;
         ipc_call_t answer;
-        msg = async_send_2(fs_exch, VFS_OUT_SYNC, file->node->devmap_handle,
+        msg = async_send_2(fs_exch, VFS_OUT_SYNC, file->node->service_id,
             file->node->index, &answer);
         
@@ -797 +797 @@
         if (read) {
                 rc = async_data_read_forward_4_1(fs_exch, VFS_OUT_READ,
-                    file->node->devmap_handle, file->node->index,
+                    file->node->service_id, file->node->index,
                     LOWER32(file->pos), UPPER32(file->pos), &answer);
         } else {
@@ -804 +804 @@
                 
                 rc = async_data_write_forward_4_1(fs_exch, VFS_OUT_WRITE,
-                    file->node->devmap_handle, file->node->index,
+                    file->node->service_id, file->node->index,
                     LOWER32(file->pos), UPPER32(file->pos), &answer);
         }
@@ -935 +935 @@
 }
 
-int vfs_truncate_internal(fs_handle_t fs_handle, devmap_handle_t devmap_handle,
+int vfs_truncate_internal(fs_handle_t fs_handle, service_id_t service_id,
     fs_index_t index, aoff64_t size)
 {
         async_exch_t *exch = vfs_exchange_grab(fs_handle);
         sysarg_t rc = async_req_4_0(exch, VFS_OUT_TRUNCATE,
-            (sysarg_t) devmap_handle, (sysarg_t) index, LOWER32(size),
+            (sysarg_t) service_id, (sysarg_t) index, LOWER32(size),
             UPPER32(size));
         vfs_exchange_release(exch);
@@ -963 +963 @@
         fibril_rwlock_write_lock(&file->node->contents_rwlock);
         rc = vfs_truncate_internal(file->node->fs_handle,
-            file->node->devmap_handle, file->node->index, size);
+            file->node->service_id, file->node->index, size);
         if (rc == EOK)
                 file->node->size = size;
@@ -997 +997 @@
         
         aid_t msg;
-        msg = async_send_3(exch, VFS_OUT_STAT, file->node->devmap_handle,
+        msg = async_send_3(exch, VFS_OUT_STAT, file->node->service_id,
             file->node->index, true, NULL);
         async_forward_fast(callid, exch, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
@@ -1050 +1050 @@
         
         aid_t msg;
-        msg = async_send_3(exch, VFS_OUT_STAT, node->devmap_handle,
+        msg = async_send_3(exch, VFS_OUT_STAT, node->service_id,
             node->index, false, NULL);
         async_forward_fast(callid, exch, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
@@ -1227 +1227 @@
         /* Check whether linking to the same file system instance. */
         if ((old_node->fs_handle != new_par_lr.triplet.fs_handle) ||
-            (old_node->devmap_handle != new_par_lr.triplet.devmap_handle)) {
+            (old_node->service_id != new_par_lr.triplet.service_id)) {
                 fibril_rwlock_write_unlock(&namespace_rwlock);
                 vfs_node_put(old_node);

uspace/srv/vfs/vfs_register.c

@@ -306 +306 @@
         list_foreach(fs_list, cur) {
                 fs_info_t *fs = list_get_instance(cur, fs_info_t, fs_link);
-                if (str_cmp(fs->vfs_info.name, name) == 0) { 
+                if (str_cmp(fs->vfs_info.name, name) == 0) {
                         handle = fs->fs_handle;
                         break;