Index: uspace/lib/fs/libfs.c
===================================================================
--- uspace/lib/fs/libfs.c	(revision a1c95da23c389f9f57b27a2bfdffd0d2c2cfa993)
+++ uspace/lib/fs/libfs.c	(revision 3dd148d953c70e48d8af23bcc31daae517c34b27)
@@ -834,5 +834,6 @@
 	
 	ops->node_put(fn);
-	
+
+
 	async_data_read_finalize(callid, &stat, sizeof(struct stat));
 	async_answer_0(rid, EOK);
@@ -862,15 +863,28 @@
 	memset(&statfs, 0, sizeof(struct statfs));
 
-	if (NULL != ops->size_block)	
-		statfs.f_bsize = ops->size_block(service_id);
-	if (NULL != ops->total_block_count)
-		statfs.f_blocks = ops->total_block_count(service_id);
-	if (NULL != ops->free_block_count)
-		statfs.f_bfree = ops->free_block_count(service_id);
-	
+	if (NULL != ops->size_block) {	
+		rc = ops->size_block(service_id, &statfs.f_bsize);
+		if (rc != EOK) goto error;
+	}
+
+	if (NULL != ops->total_block_count) {
+		rc = ops->total_block_count(service_id, &statfs.f_blocks);
+		if (rc != EOK) goto error;
+	}
+
+	if (NULL != ops->free_block_count) {
+		rc = ops->free_block_count(service_id, &statfs.f_bfree);
+		if (rc != EOK) goto error;
+	}
+
 	ops->node_put(fn);
-	
 	async_data_read_finalize(callid, &statfs, sizeof(struct statfs));
 	async_answer_0(rid, EOK);
+	return;
+
+error:
+	ops->node_put(fn);
+	async_answer_0(callid, EINVAL);
+	async_answer_0(rid, EINVAL);
 }
 
Index: uspace/lib/fs/libfs.h
===================================================================
--- uspace/lib/fs/libfs.h	(revision a1c95da23c389f9f57b27a2bfdffd0d2c2cfa993)
+++ uspace/lib/fs/libfs.h	(revision 3dd148d953c70e48d8af23bcc31daae517c34b27)
@@ -93,7 +93,7 @@
 	bool (* is_file)(fs_node_t *);
 	service_id_t (* service_get)(fs_node_t *);
-	uint32_t (* size_block)(service_id_t);
-	uint64_t (* total_block_count)(service_id_t);
-	uint64_t (* free_block_count)(service_id_t);
+	int (* size_block)(service_id_t, uint32_t *);
+	int (* total_block_count)(service_id_t, uint64_t *);
+	int (* free_block_count)(service_id_t, uint64_t *);
 } libfs_ops_t;
 
Index: uspace/srv/fs/cdfs/cdfs_ops.c
===================================================================
--- uspace/srv/fs/cdfs/cdfs_ops.c	(revision a1c95da23c389f9f57b27a2bfdffd0d2c2cfa993)
+++ uspace/srv/fs/cdfs/cdfs_ops.c	(revision 3dd148d953c70e48d8af23bcc31daae517c34b27)
@@ -625,8 +625,9 @@
 }
 
-static uint32_t cdfs_size_block(service_id_t service_id)
-{
-	uint32_t block_size = BLOCK_SIZE;
-	return block_size; 
+static int cdfs_size_block(service_id_t service_id, uint32_t *size)
+{
+	*size = BLOCK_SIZE;
+
+	return EOK; 
 }
 
Index: uspace/srv/fs/exfat/exfat_ops.c
===================================================================
--- uspace/srv/fs/exfat/exfat_ops.c	(revision a1c95da23c389f9f57b27a2bfdffd0d2c2cfa993)
+++ uspace/srv/fs/exfat/exfat_ops.c	(revision 3dd148d953c70e48d8af23bcc31daae517c34b27)
@@ -89,7 +89,7 @@
 static bool exfat_is_file(fs_node_t *node);
 static service_id_t exfat_service_get(fs_node_t *node);
-static uint32_t exfat_size_block(service_id_t);
-static uint64_t exfat_total_block_count(service_id_t);
-static uint64_t exfat_free_block_count(service_id_t);
+static int exfat_size_block(service_id_t, uint32_t *);
+static int exfat_total_block_count(service_id_t, uint64_t *);
+static int exfat_free_block_count(service_id_t, uint64_t *);
 
 /*
@@ -915,23 +915,23 @@
 }
 
-uint32_t exfat_size_block(service_id_t service_id)
+int exfat_size_block(service_id_t service_id, uint32_t *size)
 {
 	exfat_bs_t *bs;
 	bs = block_bb_get(service_id);
-	
-	return BPC(bs);
-}
-
-uint64_t exfat_total_block_count(service_id_t service_id)
+	*size = BPC(bs);
+
+	return EOK;
+}
+
+int exfat_total_block_count(service_id_t service_id, uint64_t *count)
 {
 	exfat_bs_t *bs;
 	bs = block_bb_get(service_id);
+	*count = DATA_CNT(bs);
 	
-	uint64_t block_count = DATA_CNT(bs);
-	
-	return block_count;
-}
-
-uint64_t exfat_free_block_count(service_id_t service_id)
+	return EOK;
+}
+
+int exfat_free_block_count(service_id_t service_id, uint64_t *count)
 {
 	fs_node_t *node;
@@ -943,5 +943,7 @@
 	int rc;
 
-	block_count = exfat_total_block_count(service_id);
+	rc = exfat_total_block_count(service_id, &block_count);
+	if (rc != EOK)
+		goto exit;
 
 	bs = block_bb_get(service_id);
@@ -985,5 +987,6 @@
 exit:
 	exfat_node_put(node);
-	return free_block_count;
+	*count = free_block_count;
+	return rc;
 }
 
Index: uspace/srv/fs/ext4fs/ext4fs_ops.c
===================================================================
--- uspace/srv/fs/ext4fs/ext4fs_ops.c	(revision a1c95da23c389f9f57b27a2bfdffd0d2c2cfa993)
+++ uspace/srv/fs/ext4fs/ext4fs_ops.c	(revision 3dd148d953c70e48d8af23bcc31daae517c34b27)
@@ -101,7 +101,7 @@
 static bool ext4fs_is_file(fs_node_t *node);
 static service_id_t ext4fs_service_get(fs_node_t *node);
-static uint32_t ext4fs_size_block(service_id_t);
-static uint64_t ext4fs_total_block_count(service_id_t);
-static uint64_t ext4fs_free_block_count(service_id_t);
+static int ext4fs_size_block(service_id_t, uint32_t *);
+static int ext4fs_total_block_count(service_id_t, uint64_t *);
+static int ext4fs_free_block_count(service_id_t, uint64_t *);
 
 /* Static variables */
@@ -841,5 +841,5 @@
 }
 
-uint32_t ext4fs_size_block(service_id_t service_id)
+int ext4fs_size_block(service_id_t service_id, uint32_t *size)
 {
 	ext4fs_instance_t *inst;
@@ -847,14 +847,15 @@
 	if (rc != EOK)
 		return rc;
+
 	if (NULL == inst)
 		return ENOENT;
 
 	ext4_superblock_t *sb = inst->filesystem->superblock;
-	uint32_t block_size = ext4_superblock_get_block_size(sb);
-
-	return block_size;
-}
-
-uint64_t ext4fs_total_block_count(service_id_t service_id)
+	*size = ext4_superblock_get_block_size(sb);
+
+	return EOK;
+}
+
+int ext4fs_total_block_count(service_id_t service_id, uint64_t *count)
 {
 	ext4fs_instance_t *inst;
@@ -862,14 +863,15 @@
 	if (rc != EOK)
 		return rc;
+
 	if (NULL == inst)
 		return ENOENT;
 
 	ext4_superblock_t *sb = inst->filesystem->superblock;
-	uint64_t block_count = ext4_superblock_get_blocks_count(sb);
-
-	return block_count;
-}
-
-uint64_t ext4fs_free_block_count(service_id_t service_id)
+	*count = ext4_superblock_get_blocks_count(sb);
+
+	return EOK;
+}
+
+int ext4fs_free_block_count(service_id_t service_id, uint64_t *count)
 {
 	ext4fs_instance_t *inst;
@@ -881,7 +883,7 @@
 
 	ext4_superblock_t *sb = inst->filesystem->superblock;
-	uint64_t block_count = ext4_superblock_get_free_blocks_count(sb);
-
-	return block_count;
+	*count = ext4_superblock_get_free_blocks_count(sb);
+
+	return EOK;
 }
 
Index: uspace/srv/fs/fat/fat_ops.c
===================================================================
--- uspace/srv/fs/fat/fat_ops.c	(revision a1c95da23c389f9f57b27a2bfdffd0d2c2cfa993)
+++ uspace/srv/fs/fat/fat_ops.c	(revision 3dd148d953c70e48d8af23bcc31daae517c34b27)
@@ -91,7 +91,7 @@
 static bool fat_is_file(fs_node_t *node);
 static service_id_t fat_service_get(fs_node_t *node);
-static uint32_t fat_size_block(service_id_t);
-static uint64_t fat_total_block_count(service_id_t);
-static uint64_t fat_free_block_count(service_id_t);
+static int fat_size_block(service_id_t, uint32_t *);
+static int fat_total_block_count(service_id_t, uint64_t *);
+static int fat_free_block_count(service_id_t, uint64_t *);
 
 /*
@@ -846,23 +846,25 @@
 }
 
-uint32_t fat_size_block(service_id_t service_id)
+int fat_size_block(service_id_t service_id, uint32_t *size)
 {
 	fat_bs_t *bs;
+
 	bs = block_bb_get(service_id);
-
-	return BPC(bs);
-}
-
-uint64_t fat_total_block_count(service_id_t service_id)
+	*size = BPC(bs);
+
+	return EOK;
+}
+
+int fat_total_block_count(service_id_t service_id, uint64_t *count)
 {
 	fat_bs_t *bs;
+	
 	bs = block_bb_get(service_id);
-
-	uint64_t block_count = (SPC(bs)) ? TS(bs) / SPC(bs) : 0;
-
-	return block_count;
-}
-
-uint64_t fat_free_block_count(service_id_t service_id)
+	*count = (SPC(bs)) ? TS(bs) / SPC(bs) : 0;
+
+	return EOK;
+}
+
+int fat_free_block_count(service_id_t service_id, uint64_t *count)
 {
 	fat_bs_t *bs;
@@ -874,7 +876,5 @@
 	block_count = 0;
 	bs = block_bb_get(service_id);
-	
 	clusters = (SPC(bs)) ? TS(bs) / SPC(bs) : 0;
-	
 	for (cluster_no = 0; cluster_no < clusters; cluster_no++) {
 		rc = fat_get_cluster(bs, service_id, FAT1, cluster_no, &e0);
@@ -885,6 +885,7 @@
 			block_count++;
 	}
-
-	return block_count;
+	*count = block_count;
+	
+	return EOK;
 }
 
Index: uspace/srv/fs/mfs/mfs_ops.c
===================================================================
--- uspace/srv/fs/mfs/mfs_ops.c	(revision a1c95da23c389f9f57b27a2bfdffd0d2c2cfa993)
+++ uspace/srv/fs/mfs/mfs_ops.c	(revision 3dd148d953c70e48d8af23bcc31daae517c34b27)
@@ -64,7 +64,7 @@
 static int mfs_check_sanity(struct mfs_sb_info *sbi);
 static bool is_power_of_two(uint32_t n);
-static uint32_t mfs_size_block(service_id_t service_id);
-static uint64_t mfs_total_block_count(service_id_t service_id);
-static uint64_t mfs_free_block_count(service_id_t service_id);
+static int mfs_size_block(service_id_t service_id, uint32_t *size);
+static int mfs_total_block_count(service_id_t service_id, uint64_t *count);
+static int mfs_free_block_count(service_id_t service_id, uint64_t *count);
 
 static hash_table_t open_nodes;
@@ -1135,28 +1135,29 @@
 }
 
-static uint32_t
-mfs_size_block(service_id_t service_id)
-{
-	uint32_t block_size;
-
+static int
+mfs_size_block(service_id_t service_id, uint32_t *size)
+{
 	struct mfs_instance *inst;
-	int rc = mfs_instance_get(service_id, &inst);
+	int rc;
+
+	rc = mfs_instance_get(service_id, &inst);
 	if (rc != EOK)
 		return rc;
+
 	if (NULL == inst)
 		return ENOENT;
 	
-	block_size = inst->sbi->block_size;
-
-	return block_size;
-}
-
-static uint64_t
-mfs_total_block_count(service_id_t service_id)
-{
-	uint64_t block_total;
+	*size = inst->sbi->block_size;
+
+	return EOK;
+}
+
+static int
+mfs_total_block_count(service_id_t service_id, uint64_t *count)
+{
+	struct mfs_instance *inst;
+	int rc;
 	
-	struct mfs_instance *inst;
-	int rc = mfs_instance_get(service_id, &inst);
+	rc = mfs_instance_get(service_id, &inst);
 	if (rc != EOK)
 		return rc;
@@ -1165,11 +1166,11 @@
 		return ENOENT;
 	
-	block_total = (uint64_t) MFS_BMAP_SIZE_BITS(inst->sbi, BMAP_ZONE);
-
-	return block_total;
-}
-
-static uint64_t
-mfs_free_block_count(service_id_t service_id)
+	*count = (uint64_t) MFS_BMAP_SIZE_BITS(inst->sbi, BMAP_ZONE);
+
+	return EOK;
+}
+
+static int
+mfs_free_block_count(service_id_t service_id, uint64_t *count)
 {
 	uint32_t block_free;
@@ -1184,6 +1185,7 @@
 
 	mfs_count_free_zones(inst, &block_free);
-
-	return (uint64_t)block_free;
+	*count = block_free;
+
+	return EOK;
 }
 
Index: uspace/srv/fs/udf/udf_ops.c
===================================================================
--- uspace/srv/fs/udf/udf_ops.c	(revision a1c95da23c389f9f57b27a2bfdffd0d2c2cfa993)
+++ uspace/srv/fs/udf/udf_ops.c	(revision 3dd148d953c70e48d8af23bcc31daae517c34b27)
@@ -249,5 +249,5 @@
 }
 
-static uint32_t udf_size_block(service_id_t service_id)
+static int udf_size_block(service_id_t service_id, uint32_t *size)
 {
 	udf_instance_t *instance;
@@ -259,5 +259,7 @@
 		return ENOENT;
 	
-	return instance->volumes[DEFAULT_VOL].logical_block_size;
+	*size = instance->volumes[DEFAULT_VOL].logical_block_size;
+	
+	return EOK;
 }