Index: uspace/srv/fs/cdfs/cdfs.c
===================================================================
--- uspace/srv/fs/cdfs/cdfs.c	(revision 84a1a546f62a2ba0f913f8f1bfce8d4bc68d7aa4)
+++ uspace/srv/fs/cdfs/cdfs.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -82,5 +82,5 @@
 	}
 	
-	int rc = fs_register(vfs_sess, &cdfs_vfs_info, &cdfs_ops,
+	errno_t rc = fs_register(vfs_sess, &cdfs_vfs_info, &cdfs_ops,
 	    &cdfs_libfs_ops);
 	if (rc != EOK) {
Index: uspace/srv/fs/cdfs/cdfs_ops.c
===================================================================
--- uspace/srv/fs/cdfs/cdfs_ops.c	(revision 84a1a546f62a2ba0f913f8f1bfce8d4bc68d7aa4)
+++ uspace/srv/fs/cdfs/cdfs_ops.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -331,5 +331,5 @@
 };
 
-static int cdfs_node_get(fs_node_t **rfn, service_id_t service_id,
+static errno_t cdfs_node_get(fs_node_t **rfn, service_id_t service_id,
     fs_index_t index)
 {
@@ -351,5 +351,5 @@
 }
 
-static int cdfs_root_get(fs_node_t **rfn, service_id_t service_id)
+static errno_t cdfs_root_get(fs_node_t **rfn, service_id_t service_id)
 {
 	return cdfs_node_get(rfn, service_id, CDFS_SOME_ROOT);
@@ -371,5 +371,5 @@
 }
 
-static int create_node(fs_node_t **rfn, cdfs_t *fs, int lflag,
+static errno_t create_node(fs_node_t **rfn, cdfs_t *fs, int lflag,
     fs_index_t index)
 {
@@ -392,5 +392,5 @@
 	
 	fs_node_t *rootfn;
-	int rc = cdfs_root_get(&rootfn, fs->service_id);
+	errno_t rc = cdfs_root_get(&rootfn, fs->service_id);
 	
 	assert(rc == EOK);
@@ -417,5 +417,5 @@
 }
 
-static int link_node(fs_node_t *pfn, fs_node_t *fn, const char *name)
+static errno_t link_node(fs_node_t *pfn, fs_node_t *fn, const char *name)
 {
 	cdfs_node_t *parent = CDFS_NODE(pfn);
@@ -460,5 +460,5 @@
 static char *cdfs_decode_str(void *data, size_t dsize, cdfs_enc_t enc)
 {
-	int rc;
+	errno_t rc;
 	char *str;
 	uint16_t *buf;
@@ -566,5 +566,5 @@
 }
 
-static int cdfs_readdir(cdfs_t *fs, fs_node_t *fs_node)
+static errno_t cdfs_readdir(cdfs_t *fs, fs_node_t *fs_node)
 {
 	cdfs_node_t *node = CDFS_NODE(fs_node);
@@ -580,5 +580,5 @@
 	for (uint32_t i = 0; i < blocks; i++) {
 		block_t *block;
-		int rc = block_get(&block, fs->service_id, node->lba + i, BLOCK_FLAGS_NONE);
+		errno_t rc = block_get(&block, fs->service_id, node->lba + i, BLOCK_FLAGS_NONE);
 		if (rc != EOK)
 			return rc;
@@ -614,5 +614,5 @@
 			
 			fs_node_t *fn;
-			int rc = create_node(&fn, fs, dentry_type,
+			errno_t rc = create_node(&fn, fs, dentry_type,
 			    (node->lba + i) * BLOCK_SIZE + offset);
 			if (rc != EOK)
@@ -652,5 +652,5 @@
 	
 	block_t *block;
-	int rc = block_get(&block, fs->service_id, lba, BLOCK_FLAGS_NONE);
+	errno_t rc = block_get(&block, fs->service_id, lba, BLOCK_FLAGS_NONE);
 	if (rc != EOK)
 		return NULL;
@@ -698,10 +698,10 @@
 }
 
-static int cdfs_match(fs_node_t **fn, fs_node_t *pfn, const char *component)
+static errno_t cdfs_match(fs_node_t **fn, fs_node_t *pfn, const char *component)
 {
 	cdfs_node_t *parent = CDFS_NODE(pfn);
 	
 	if (!parent->processed) {
-		int rc = cdfs_readdir(parent->fs, pfn);
+		errno_t rc = cdfs_readdir(parent->fs, pfn);
 		if (rc != EOK)
 			return rc;
@@ -719,5 +719,5 @@
 }
 
-static int cdfs_node_open(fs_node_t *fn)
+static errno_t cdfs_node_open(fs_node_t *fn)
 {
 	cdfs_node_t *node = CDFS_NODE(fn);
@@ -730,5 +730,5 @@
 }
 
-static int cdfs_node_put(fs_node_t *fn)
+static errno_t cdfs_node_put(fs_node_t *fn)
 {
 	/* Nothing to do */
@@ -736,5 +736,5 @@
 }
 
-static int cdfs_create_node(fs_node_t **fn, service_id_t service_id, int lflag)
+static errno_t cdfs_create_node(fs_node_t **fn, service_id_t service_id, int lflag)
 {
 	/* Read-only */
@@ -742,5 +742,5 @@
 }
 
-static int cdfs_destroy_node(fs_node_t *fn)
+static errno_t cdfs_destroy_node(fs_node_t *fn)
 {
 	/* Read-only */
@@ -748,5 +748,5 @@
 }
 
-static int cdfs_link_node(fs_node_t *pfn, fs_node_t *cfn, const char *name)
+static errno_t cdfs_link_node(fs_node_t *pfn, fs_node_t *cfn, const char *name)
 {
 	/* Read-only */
@@ -754,5 +754,5 @@
 }
 
-static int cdfs_unlink_node(fs_node_t *pfn, fs_node_t *cfn, const char *name)
+static errno_t cdfs_unlink_node(fs_node_t *pfn, fs_node_t *cfn, const char *name)
 {
 	/* Read-only */
@@ -760,5 +760,5 @@
 }
 
-static int cdfs_has_children(bool *has_children, fs_node_t *fn)
+static errno_t cdfs_has_children(bool *has_children, fs_node_t *fn)
 {
 	cdfs_node_t *node = CDFS_NODE(fn);
@@ -806,5 +806,5 @@
 }
 
-static int cdfs_size_block(service_id_t service_id, uint32_t *size)
+static errno_t cdfs_size_block(service_id_t service_id, uint32_t *size)
 {
 	*size = BLOCK_SIZE;
@@ -813,5 +813,5 @@
 }
 
-static int cdfs_total_block_count(service_id_t service_id, uint64_t *count)
+static errno_t cdfs_total_block_count(service_id_t service_id, uint64_t *count)
 {
 	*count = 0;
@@ -820,5 +820,5 @@
 }
 
-static int cdfs_free_block_count(service_id_t service_id, uint64_t *count)
+static errno_t cdfs_free_block_count(service_id_t service_id, uint64_t *count)
 {
 	*count = 0;
@@ -851,5 +851,5 @@
 /** Verify that escape sequence corresonds to one of the allowed encoding
  * escape sequences allowed for Joliet. */
-static int cdfs_verify_joliet_esc_seq(uint8_t *seq)
+static errno_t cdfs_verify_joliet_esc_seq(uint8_t *seq)
 {
 	size_t i, j, k;
@@ -895,5 +895,5 @@
  * @return 		EOK if found, ENOENT if not
  */
-static int cdfs_find_joliet_svd(service_id_t sid, cdfs_lba_t altroot,
+static errno_t cdfs_find_joliet_svd(service_id_t sid, cdfs_lba_t altroot,
     uint32_t *rlba, uint32_t *rsize, char **vol_ident)
 {
@@ -902,5 +902,5 @@
 	for (bi = altroot + 17; ; bi++) {
 		block_t *block;
-		int rc = block_get(&block, sid, bi, BLOCK_FLAGS_NONE);
+		errno_t rc = block_get(&block, sid, bi, BLOCK_FLAGS_NONE);
 		if (rc != EOK)
 			break;
@@ -963,10 +963,10 @@
 
 /** Read the volume descriptors. */
-static int iso_read_vol_desc(service_id_t sid, cdfs_lba_t altroot,
+static errno_t iso_read_vol_desc(service_id_t sid, cdfs_lba_t altroot,
     uint32_t *rlba, uint32_t *rsize, cdfs_enc_t *enc, char **vol_ident)
 {
 	/* First 16 blocks of isofs are empty */
 	block_t *block;
-	int rc = block_get(&block, sid, altroot + 16, BLOCK_FLAGS_NONE);
+	errno_t rc = block_get(&block, sid, altroot + 16, BLOCK_FLAGS_NONE);
 	if (rc != EOK)
 		return rc;
@@ -1036,10 +1036,10 @@
 }
 
-static int iso_readfs(cdfs_t *fs, fs_node_t *rfn,
+static errno_t iso_readfs(cdfs_t *fs, fs_node_t *rfn,
     cdfs_lba_t altroot)
 {
 	cdfs_node_t *node = CDFS_NODE(rfn);
 	
-	int rc = iso_read_vol_desc(fs->service_id, altroot, &node->lba,
+	errno_t rc = iso_read_vol_desc(fs->service_id, altroot, &node->lba,
 	    &node->size, &fs->enc, &fs->vol_ident);
 	if (rc != EOK)
@@ -1064,5 +1064,5 @@
 	
 	/* Create root node */
-	int rc = create_node(&rfn, fs, L_DIRECTORY, cdfs_index++);
+	errno_t rc = create_node(&rfn, fs, L_DIRECTORY, cdfs_index++);
 	
 	if ((rc != EOK) || (!rfn))
@@ -1086,10 +1086,10 @@
 }
 
-static int cdfs_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
+static errno_t cdfs_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
 {
 	char *vol_ident;
 
 	/* Initialize the block layer */
-	int rc = block_init(service_id, BLOCK_SIZE);
+	errno_t rc = block_init(service_id, BLOCK_SIZE);
 	if (rc != EOK)
 		return rc;
@@ -1144,9 +1144,9 @@
 }
 
-static int cdfs_mounted(service_id_t service_id, const char *opts,
+static errno_t cdfs_mounted(service_id_t service_id, const char *opts,
     fs_index_t *index, aoff64_t *size)
 {
 	/* Initialize the block layer */
-	int rc = block_init(service_id, BLOCK_SIZE);
+	errno_t rc = block_init(service_id, BLOCK_SIZE);
 	if (rc != EOK)
 		return rc;
@@ -1238,5 +1238,5 @@
 }
 
-static int cdfs_unmounted(service_id_t service_id)
+static errno_t cdfs_unmounted(service_id_t service_id)
 {
 	cdfs_t *fs;
@@ -1250,5 +1250,5 @@
 }
 
-static int cdfs_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
+static errno_t cdfs_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
     size_t *rbytes)
 {
@@ -1266,5 +1266,5 @@
 	
 	if (!node->processed) {
-		int rc = cdfs_readdir(node->fs, FS_NODE(node));
+		errno_t rc = cdfs_readdir(node->fs, FS_NODE(node));
 		if (rc != EOK)
 			return rc;
@@ -1290,5 +1290,5 @@
 			
 			block_t *block;
-			int rc = block_get(&block, service_id, node->lba + lba,
+			errno_t rc = block_get(&block, service_id, node->lba + lba,
 			    BLOCK_FLAGS_NONE);
 			if (rc != EOK) {
@@ -1321,5 +1321,5 @@
 }
 
-static int cdfs_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
+static errno_t cdfs_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
     size_t *wbytes, aoff64_t *nsize)
 {
@@ -1332,5 +1332,5 @@
 }
 
-static int cdfs_truncate(service_id_t service_id, fs_index_t index,
+static errno_t cdfs_truncate(service_id_t service_id, fs_index_t index,
     aoff64_t size)
 {
@@ -1373,5 +1373,5 @@
 }
 
-static int cdfs_close(service_id_t service_id, fs_index_t index)
+static errno_t cdfs_close(service_id_t service_id, fs_index_t index)
 {
 	/* Root node is always in memory */
@@ -1399,5 +1399,5 @@
 }
 
-static int cdfs_destroy(service_id_t service_id, fs_index_t index)
+static errno_t cdfs_destroy(service_id_t service_id, fs_index_t index)
 {
 	/*
@@ -1409,5 +1409,5 @@
 }
 
-static int cdfs_sync(service_id_t service_id, fs_index_t index)
+static errno_t cdfs_sync(service_id_t service_id, fs_index_t index)
 {
 	/*