Index: uspace/srv/vfs/vfs.h
===================================================================
--- uspace/srv/vfs/vfs.h	(revision cad9c7229b14b0f744c8fbeabc9dfa53ac9bdb4c)
+++ uspace/srv/vfs/vfs.h	(revision eb27ce5a8fc10aea5ca8d1e35996165a9eb406d8)
@@ -139,4 +139,9 @@
 } vfs_triplet_t;
 
+typedef struct {
+	vfs_triplet_t triplet;
+	size_t size;
+} vfs_lookup_res_t;
+
 /**
  * Instances of this type represent an active, in-memory VFS node and any state
@@ -199,9 +204,9 @@
 extern int fs_name_to_handle(char *, bool);
 
-extern int vfs_lookup_internal(char *, size_t, vfs_triplet_t *, size_t *,
+extern int vfs_lookup_internal(char *, size_t, vfs_lookup_res_t *,
     vfs_pair_t *);
 
 extern bool vfs_nodes_init(void);
-extern vfs_node_t *vfs_node_get(vfs_triplet_t *, size_t);
+extern vfs_node_t *vfs_node_get(vfs_lookup_res_t *);
 extern void vfs_node_put(vfs_node_t *);
 
Index: uspace/srv/vfs/vfs_node.c
===================================================================
--- uspace/srv/vfs/vfs_node.c	(revision cad9c7229b14b0f744c8fbeabc9dfa53ac9bdb4c)
+++ uspace/srv/vfs/vfs_node.c	(revision eb27ce5a8fc10aea5ca8d1e35996165a9eb406d8)
@@ -1,4 +1,4 @@
 /*
- * Copyright (c) 2007 Jakub Jermar
+ * Copyright (c) 2008 Jakub Jermar
  * All rights reserved.
  *
@@ -122,15 +122,14 @@
  * vfs_node_put() on it.
  *
- * @param triplet	Triplet encoding the identity of the VFS node.
- * @param size		Size of the node as filled by vfs_lookup_internal().
+ * @param result	Populated lookup result structure.
  *
  * @return		VFS node corresponding to the given triplet.
  */
-vfs_node_t *vfs_node_get(vfs_triplet_t *triplet, size_t size)
+vfs_node_t *vfs_node_get(vfs_lookup_res_t *result)
 {
 	unsigned long key[] = {
-		[KEY_FS_HANDLE] = triplet->fs_handle,
-		[KEY_DEV_HANDLE] = triplet->dev_handle,
-		[KEY_INDEX] = triplet->index
+		[KEY_FS_HANDLE] = result->triplet.fs_handle,
+		[KEY_DEV_HANDLE] = result->triplet.dev_handle,
+		[KEY_INDEX] = result->triplet.index
 	};
 	link_t *tmp;
@@ -146,8 +145,8 @@
 		}
 		memset(node, 0, sizeof(vfs_node_t));
-		node->fs_handle = triplet->fs_handle;
-		node->dev_handle = triplet->fs_handle;
-		node->index = triplet->index;
-		node->size = size;
+		node->fs_handle = result->triplet.fs_handle;
+		node->dev_handle = result->triplet.fs_handle;
+		node->index = result->triplet.index;
+		node->size = result->size;
 		link_initialize(&node->nh_link);
 		rwlock_initialize(&node->contents_rwlock);
@@ -157,5 +156,5 @@
 	}
 
-	assert(node->size == size);
+	assert(node->size == result->size);
 
 	_vfs_node_addref(node);
Index: uspace/srv/vfs/vfs_ops.c
===================================================================
--- uspace/srv/vfs/vfs_ops.c	(revision cad9c7229b14b0f744c8fbeabc9dfa53ac9bdb4c)
+++ uspace/srv/vfs/vfs_ops.c	(revision eb27ce5a8fc10aea5ca8d1e35996165a9eb406d8)
@@ -71,7 +71,5 @@
  * @param path		Path to be resolved; it needn't be an ASCIIZ string.
  * @param len		Number of path characters pointed by path.
- * @param result	Empty node structure where the result will be stored.
- * @param size		Storage where the size of the node will be stored. Can
- *			be NULL.
+ * @param result	Empty structure where the lookup result will be stored.
  * @param altroot	If non-empty, will be used instead of rootfs as the root
  *			of the whole VFS tree.
@@ -79,6 +77,6 @@
  * @return		EOK on success or an error code from errno.h.
  */
-int vfs_lookup_internal(char *path, size_t len, vfs_triplet_t *result,
-    size_t *size, vfs_pair_t *altroot)
+int vfs_lookup_internal(char *path, size_t len, vfs_lookup_res_t *result,
+    vfs_pair_t *altroot)
 {
 	vfs_pair_t *root;
@@ -180,9 +178,8 @@
 
 	if (rc == EOK) {
-		result->fs_handle = (int) IPC_GET_ARG1(answer);
-		result->dev_handle = (int) IPC_GET_ARG2(answer);
-		result->index = (int) IPC_GET_ARG3(answer);
-		if (size)
-			*size = (size_t) IPC_GET_ARG4(answer);
+		result->triplet.fs_handle = (int) IPC_GET_ARG1(answer);
+		result->triplet.dev_handle = (int) IPC_GET_ARG2(answer);
+		result->triplet.index = (int) IPC_GET_ARG3(answer);
+		result->size = (size_t) IPC_GET_ARG4(answer);
 	}
 
@@ -197,6 +194,5 @@
 };
 
-static int lookup_root(int fs_handle, int dev_handle, vfs_triplet_t *root,
-    size_t *size)
+static int lookup_root(int fs_handle, int dev_handle, vfs_lookup_res_t *result)
 {
 	vfs_pair_t altroot = {
@@ -205,5 +201,5 @@
 	};
 
-	return vfs_lookup_internal("/", strlen("/"), root, size, &altroot);
+	return vfs_lookup_internal("/", strlen("/"), result, &altroot);
 }
 
@@ -305,7 +301,6 @@
 	 */
 	int rc;
-	vfs_triplet_t mounted_root;
-	size_t mrsz;
-	rc = lookup_root(fs_handle, dev_handle, &mounted_root, &mrsz);
+	vfs_lookup_res_t mr_res;
+	rc = lookup_root(fs_handle, dev_handle, &mr_res);
 	if (rc != EOK) {
 		free(buf);
@@ -313,5 +308,5 @@
 		return;
 	}
-	vfs_node_t *mr_node = vfs_node_get(&mounted_root, mrsz);
+	vfs_node_t *mr_node = vfs_node_get(&mr_res);
 	if (!mr_node) {
 		free(buf);
@@ -323,6 +318,5 @@
 	 * Finally, we need to resolve the path to the mountpoint. 
 	 */
-	vfs_triplet_t mp;
-	size_t mpsz;
+	vfs_lookup_res_t mp_res;
 	futex_down(&rootfs_futex);
 	if (rootfs.fs_handle) {
@@ -331,5 +325,5 @@
 		 */
 		rwlock_write_lock(&namespace_rwlock);
-		rc = vfs_lookup_internal(buf, size, &mp, &mpsz, NULL);
+		rc = vfs_lookup_internal(buf, size, &mp_res, NULL);
 		if (rc != EOK) {
 			/*
@@ -343,5 +337,5 @@
 			return;
 		}
-		mp_node = vfs_node_get(&mp, mpsz);
+		mp_node = vfs_node_get(&mp_res);
 		if (!mp_node) {
 			rwlock_write_unlock(&namespace_rwlock);
@@ -366,5 +360,5 @@
 			 * For this simple, but important case, we are done.
 			 */
-			rootfs = mounted_root;
+			rootfs = mr_res.triplet;
 			futex_up(&rootfs_futex);
 			free(buf);
@@ -393,13 +387,14 @@
 	 */
 
-	int phone = vfs_grab_phone(mp.fs_handle);
+	int phone = vfs_grab_phone(mp_res.triplet.fs_handle);
 	/* Later we can use ARG3 to pass mode/flags. */
-	aid_t req1 = async_send_3(phone, VFS_MOUNT, (ipcarg_t) mp.dev_handle,
-	    (ipcarg_t) mp.index, 0, NULL);
+	aid_t req1 = async_send_3(phone, VFS_MOUNT,
+	    (ipcarg_t) mp_res.triplet.dev_handle,
+	    (ipcarg_t) mp_res.triplet.index, 0, NULL);
 	/* The second call uses the same method. */
 	aid_t req2 = async_send_3(phone, VFS_MOUNT,
-	    (ipcarg_t) mounted_root.fs_handle,
-	    (ipcarg_t) mounted_root.dev_handle, (ipcarg_t) mounted_root.index,
-	    NULL);
+	    (ipcarg_t) mr_res.triplet.fs_handle,
+	    (ipcarg_t) mr_res.triplet.dev_handle,
+	    (ipcarg_t) mr_res.triplet.index, NULL);
 	vfs_release_phone(phone);
 
@@ -479,7 +474,6 @@
 	 * The path is now populated and we can call vfs_lookup_internal().
 	 */
-	vfs_triplet_t triplet;
-	size_t size;
-	rc = vfs_lookup_internal(path, len, &triplet, &size, NULL);
+	vfs_lookup_res_t lr;
+	rc = vfs_lookup_internal(path, len, &lr, NULL);
 	if (rc) {
 		rwlock_read_unlock(&namespace_rwlock);
@@ -494,5 +488,5 @@
 	free(path);
 
-	vfs_node_t *node = vfs_node_get(&triplet, size);
+	vfs_node_t *node = vfs_node_get(&lr);
 	rwlock_read_unlock(&namespace_rwlock);