Index: uspace/app/bdsh/cmds/modules/cat/cat.c
===================================================================
--- uspace/app/bdsh/cmds/modules/cat/cat.c	(revision 40feeac3d6d981d671abe77b20b3aa999c586faf)
+++ uspace/app/bdsh/cmds/modules/cat/cat.c	(revision 8e3498b351ae109f7ad16592a1f108e3bd44c829)
@@ -180,10 +180,12 @@
     off64_t head, off64_t tail, bool tail_first)
 {
-	int fd, bytes = 0, count = 0, reads = 0;
+	int fd, count = 0, reads = 0;
+	size_t bytes;
 	char *buff = NULL;
-	int i;
+	size_t i;
 	size_t offset = 0, copied_bytes = 0;
 	off64_t file_size = 0, length = 0;
 	aoff64_t pos = 0;
+	int rc;
 
 	bool reading_stdin = dash_represents_stdin && (str_cmp(fname, "-") == 0);
@@ -250,8 +252,9 @@
 		}
 		
-		bytes = vfs_read(fd, &pos, buff + copied_bytes, bytes_to_read);
+		rc = vfs_read(fd, &pos, buff + copied_bytes, bytes_to_read,
+		    &bytes);
 		copied_bytes = 0;
 
-		if (bytes > 0) {
+		if (rc == EOK && bytes > 0) {
 			buff[bytes] = '\0';
 			offset = 0;
@@ -284,8 +287,8 @@
 		if (reading_stdin)
 			fflush(stdout);
-	} while (bytes > 0 && !should_quit && (count < length || length == CAT_FULL_FILE));
+	} while (rc == EOK && bytes > 0 && !should_quit && (count < length || length == CAT_FULL_FILE));
 
 	vfs_put(fd);
-	if (bytes == -1) {
+	if (rc != EOK) {
 		printf("Error reading %s\n", fname);
 		free(buff);
Index: uspace/app/bdsh/cmds/modules/cmp/cmp.c
===================================================================
--- uspace/app/bdsh/cmds/modules/cmp/cmp.c	(revision 40feeac3d6d981d671abe77b20b3aa999c586faf)
+++ uspace/app/bdsh/cmds/modules/cmp/cmp.c	(revision 8e3498b351ae109f7ad16592a1f108e3bd44c829)
@@ -72,9 +72,9 @@
 static int cmp_files(const char *fn0, const char *fn1)
 {
-	int rc = 0;
+	int rc = EOK;
 	const char *fn[2] = {fn0, fn1};
 	int fd[2] = {-1, -1};
 	char buffer[2][CMP_BUFLEN];
-	ssize_t offset[2];
+	size_t offset[2];
 	aoff64_t pos[2] = {};
 
@@ -90,22 +90,16 @@
 	do {
 		for (int i = 0; i < 2; i++) {
-			offset[i] = 0;
-			ssize_t size;
-			do {
-				size = vfs_read(fd[i], &pos[i],
-				    buffer[i] + offset[i],
-				    CMP_BUFLEN - offset[i]);
-				if (size < 0) {
-					rc = size;
-					printf("Error reading from %s\n",
-					    fn[i]);
-					goto end;
-				}
-				offset[i] += size;
-			} while (size && offset[i] < CMP_BUFLEN);
+			rc = vfs_read(fd[i], &pos[i], buffer[i], CMP_BUFLEN,
+			    &offset[i]);
+			if (rc != EOK) {
+				printf("Error reading from %s\n",
+				    fn[i]);
+				goto end;
+			}
 		}
 
 		if (offset[0] != offset[1] ||
 		    memcmp(buffer[0], buffer[1], offset[0]) != 0) {
+			printf("Return 1\n");
 			rc = 1;
 			goto end;
@@ -149,5 +143,5 @@
 
 	rc = cmp_files(argv[optind], argv[optind + 1]);
-	if (rc)
+	if (rc != EOK)
 		return CMD_FAILURE;
 	else
Index: uspace/app/bdsh/cmds/modules/cp/cp.c
===================================================================
--- uspace/app/bdsh/cmds/modules/cp/cp.c	(revision 40feeac3d6d981d671abe77b20b3aa999c586faf)
+++ uspace/app/bdsh/cmds/modules/cp/cp.c	(revision 8e3498b351ae109f7ad16592a1f108e3bd44c829)
@@ -66,5 +66,5 @@
 } dentry_type_t;
 
-static int64_t copy_file(const char *src, const char *dest,
+static int copy_file(const char *src, const char *dest,
     size_t blen, int vb);
 
@@ -175,8 +175,8 @@
 }
 
-static int64_t do_copy(const char *src, const char *dest,
+static int do_copy(const char *src, const char *dest,
     size_t blen, int vb, int recursive, int force, int interactive)
 {
-	int r = -1;
+	int rc = EOK;
 	char dest_path[PATH_MAX];
 	char src_path[PATH_MAX];
@@ -217,4 +217,5 @@
 				printf("The dest directory %s does not exists",
 				    dest_path);
+				rc = ENOENT;
 				goto exit;
 			}
@@ -224,4 +225,5 @@
 			printf("Cannot overwrite existing directory %s\n",
 			    dest_path);
+			rc = EEXIST;
 			goto exit;
 		} else if (dest_type == TYPE_FILE) {
@@ -233,5 +235,6 @@
 			 */
 			if (force && !interactive) {
-				if (vfs_unlink_path(dest_path) != EOK) {
+				rc = vfs_unlink_path(dest_path);
+				if (rc != EOK) {
 					printf("Unable to remove %s\n",
 					    dest_path);
@@ -244,5 +247,6 @@
 				if (overwrite) {
 					printf("Overwriting file: %s\n", dest_path);
-					if (vfs_unlink_path(dest_path) != EOK) {
+					rc = vfs_unlink_path(dest_path);
+					if (rc != EOK) {
 						printf("Unable to remove %s\n", dest_path);
 						goto exit;
@@ -250,9 +254,10 @@
 				} else {
 					printf("Not overwriting file: %s\n", dest_path);
-					r = 0;
+					rc = EOK;
 					goto exit;
 				}
 			} else {
 				printf("File already exists: %s\n", dest_path);
+				rc = EEXIST;
 				goto exit;
 			}
@@ -260,5 +265,5 @@
 
 		/* call copy_file and exit */
-		r = (copy_file(src, dest_path, blen, vb) < 0);
+		rc = (copy_file(src, dest_path, blen, vb) < 0);
 
 	} else if (src_type == TYPE_DIR) {
@@ -268,7 +273,9 @@
 			printf("Cannot copy the %s directory without the "
 			    "-r option\n", src);
+			rc = EINVAL;
 			goto exit;
 		} else if (dest_type == TYPE_FILE) {
 			printf("Cannot overwrite a file with a directory\n");
+			rc = EEXIST;
 			goto exit;
 		}
@@ -293,6 +300,7 @@
 				merge_paths(dest_path, PATH_MAX, src_dirname);
 
-				if (vfs_link_path(dest_path, KIND_DIRECTORY,
-				    NULL) != EOK) {
+				rc = vfs_link_path(dest_path, KIND_DIRECTORY,
+				    NULL);
+				if (rc != EOK) {
 					printf("Unable to create "
 					    "dest directory %s\n", dest_path);
@@ -308,6 +316,6 @@
 			 * e.g. cp -r /src /data/new_dir_src
 			 */
-			if (vfs_link_path(dest_path, KIND_DIRECTORY,
-			    NULL) != EOK) {
+			rc = vfs_link_path(dest_path, KIND_DIRECTORY, NULL);
+			if (rc != EOK) {
 				printf("Unable to create "
 				    "dest directory %s\n", dest_path);
@@ -321,4 +329,5 @@
 			/* Something strange is happening... */
 			printf("Unable to open src %s directory\n", src);
+			rc = ENOENT;
 			goto exit;
 		}
@@ -348,4 +357,5 @@
 				printf("Cannot copy a directory "
 				    "into itself\n");
+				rc = EEXIST;
 				goto exit;
 			}
@@ -355,7 +365,7 @@
 
 			/* Recursively call do_copy() */
-			r = do_copy(src_dent, dest_dent, blen, vb, recursive,
+			rc = do_copy(src_dent, dest_dent, blen, vb, recursive,
 			    force, interactive);
-			if (r)
+			if (rc != EOK)
 				goto exit;
 
@@ -367,13 +377,14 @@
 	if (dir)
 		closedir(dir);
-	return r;
-}
-
-static int64_t copy_file(const char *src, const char *dest,
+	return rc;
+}
+
+static int copy_file(const char *src, const char *dest,
 	size_t blen, int vb)
 {
-	int fd1, fd2, bytes;
+	int fd1, fd2;
+	size_t rbytes, wbytes;
+	int rc;
 	off64_t total;
-	int64_t copied = 0;
 	char *buff = NULL;
 	aoff64_t posr = 0, posw = 0;
@@ -410,17 +421,17 @@
 		printf("Unable to allocate enough memory to read %s\n",
 		    src);
-		copied = -1;
+		rc = ENOMEM;
 		goto out;
 	}
 
-	while ((bytes = vfs_read(fd1, &posr, buff, blen)) > 0) {
-		if ((bytes = vfs_write(fd2, &posw, buff, bytes)) < 0)
-			break;
-		copied += bytes;
-	}
-
-	if (bytes < 0) {
-		printf("\nError copying %s, (%d)\n", src, bytes);
-		copied = bytes;
+	while ((rc = vfs_read(fd1, &posr, buff, blen, &rbytes)) == EOK &&
+	    rbytes > 0) {
+		if ((rc = vfs_write(fd2, &posw, buff, rbytes, &wbytes)) != EOK)
+			break;
+	}
+
+	if (rc != EOK) {
+		printf("\nError copying %s, (%d)\n", src, rc);
+		return rc;
 	}
 
@@ -430,5 +441,5 @@
 	if (buff)
 		free(buff);
-	return copied;
+	return rc;
 }
 
Index: uspace/app/bdsh/cmds/modules/mkfile/mkfile.c
===================================================================
--- uspace/app/bdsh/cmds/modules/mkfile/mkfile.c	(revision 40feeac3d6d981d671abe77b20b3aa999c586faf)
+++ uspace/app/bdsh/cmds/modules/mkfile/mkfile.c	(revision 8e3498b351ae109f7ad16592a1f108e3bd44c829)
@@ -85,17 +85,20 @@
  *
  * @param str	String containing the size specification.
- * @return	Non-negative size in bytes on success, -1 on failure.
+ * @param rsize	Place to store size in bytes
+ * @return	EOK on success or error code
  */
-static ssize_t read_size(const char *str)
+static int read_size(const char *str, size_t *rsize)
 {
-	ssize_t number, unit;
+	size_t number, unit;
 	char *ep;
 
 	number = strtol(str, &ep, 10);
-	if (ep[0] == '\0')
-		return number;
+	if (ep[0] == '\0') {
+		*rsize = number;
+		return EOK;
+	}
 
 	if (ep[1] != '\0')
-		    return -1;
+		    return EINVAL;
 
 	switch (tolower(ep[0])) {
@@ -103,8 +106,9 @@
 	case 'm': unit = 1024*1024; break;
 	case 'g': unit = 1024*1024*1024; break;
-	default: return -1;
-	}
-
-	return number * unit;
+	default: return EINVAL;
+	}
+
+	*rsize = number * unit;
+	return EOK;
 }
 
@@ -114,7 +118,9 @@
 	int c, opt_ind;
 	int fd;
-	ssize_t file_size;
-	ssize_t total_written;
-	ssize_t to_write, rc, rc2 = 0;
+	size_t file_size;
+	size_t total_written;
+	size_t to_write;
+	size_t nwritten;
+	int rc;
 	char *file_name;
 	void *buffer;
@@ -136,6 +142,6 @@
 			break;
 		case 's':
-			file_size = read_size(optarg);
-			if (file_size < 0) {
+			rc = read_size(optarg, &file_size);
+			if (rc != EOK) {
 				printf("%s: Invalid file size specification.\n",
 				    cmdname);
@@ -166,6 +172,6 @@
 		
 		pos = file_size - 1;
-		rc2 = vfs_write(fd, &pos, &byte, sizeof(char));
-		if (rc2 < 0) {
+		rc = vfs_write(fd, &pos, &byte, sizeof(char), &nwritten);
+		if (rc != EOK) {
 			vfs_put(fd);
 			goto error;
@@ -183,6 +189,6 @@
 	while (total_written < file_size) {
 		to_write = min(file_size - total_written, BUFFER_SIZE);
-		rc = vfs_write(fd, &pos, buffer, to_write);
-		if (rc <= 0) {
+		rc = vfs_write(fd, &pos, buffer, to_write, &nwritten);
+		if (rc != EOK) {
 			printf("%s: Error writing file (%d).\n", cmdname, errno);
 			vfs_put(fd);
@@ -190,5 +196,5 @@
 			return CMD_FAILURE;
 		}
-		total_written += rc;
+		total_written += nwritten;
 	}
 
Index: uspace/app/sysinst/futil.c
===================================================================
--- uspace/app/sysinst/futil.c	(revision 40feeac3d6d981d671abe77b20b3aa999c586faf)
+++ uspace/app/sysinst/futil.c	(revision 8e3498b351ae109f7ad16592a1f108e3bd44c829)
@@ -57,5 +57,5 @@
 {
 	int sf, df;
-	ssize_t nr, nw;
+	size_t nr, nw;
 	int rc;
 	aoff64_t posr = 0, posw = 0;
@@ -72,14 +72,15 @@
 
 	do {
-		nr = vfs_read(sf, &posr, buf, BUF_SIZE);
+		rc = vfs_read(sf, &posr, buf, BUF_SIZE, &nr);
+		if (rc != EOK)
+			goto error;
 		if (nr == 0)
 			break;
-		if (nr < 0)
-			return EIO;
-
-		nw = vfs_write(df, &posw, buf, nr);
-		if (nw <= 0)
-			return EIO;
-	} while (true);
+
+		rc= vfs_write(df, &posw, buf, nr, &nw);
+		if (rc != EOK)
+			goto error;
+
+	} while (nr == BUF_SIZE);
 
 	(void) vfs_put(sf);
@@ -90,4 +91,8 @@
 
 	return EOK;
+error:
+	vfs_put(sf);
+	vfs_put(df);
+	return rc;
 }
 
@@ -156,5 +161,6 @@
 {
 	int sf;
-	ssize_t nr;
+	size_t nr;
+	int rc;
 	size_t fsize;
 	char *data;
@@ -168,5 +174,5 @@
 		vfs_put(sf);
 		return EIO;
-	}	
+	}
 
 	fsize = st.size;
@@ -178,6 +184,6 @@
 	}
 
-	nr = vfs_read(sf, (aoff64_t []) { 0 }, data, fsize);
-	if (nr != (ssize_t)fsize) {
+	rc = vfs_read(sf, (aoff64_t []) { 0 }, data, fsize, &nr);
+	if (rc != EOK || nr != fsize) {
 		vfs_put(sf);
 		free(data);
Index: uspace/app/taskdump/elf_core.c
===================================================================
--- uspace/app/taskdump/elf_core.c	(revision 40feeac3d6d981d671abe77b20b3aa999c586faf)
+++ uspace/app/taskdump/elf_core.c	(revision 8e3498b351ae109f7ad16592a1f108e3bd44c829)
@@ -97,5 +97,6 @@
 
 	int fd;
-	ssize_t rc;
+	int rc;
+	size_t nwr;
 	unsigned int i;
 
@@ -206,6 +207,6 @@
 	}
 
-	rc = vfs_write(fd, &pos, &elf_hdr, sizeof(elf_hdr));
-	if (rc != sizeof(elf_hdr)) {
+	rc = vfs_write(fd, &pos, &elf_hdr, sizeof(elf_hdr), &nwr);
+	if (rc != EOK) {
 		printf("Failed writing ELF header.\n");
 		free(p_hdr);
@@ -214,6 +215,6 @@
 
 	for (i = 0; i < n_ph; ++i) {
-		rc = vfs_write(fd, &pos, &p_hdr[i], sizeof(p_hdr[i]));
-		if (rc != sizeof(p_hdr[i])) {
+		rc = vfs_write(fd, &pos, &p_hdr[i], sizeof(p_hdr[i]), &nwr);
+		if (rc != EOK) {
 			printf("Failed writing program header.\n");
 			free(p_hdr);
@@ -231,6 +232,6 @@
 	note.type = NT_PRSTATUS;
 
-	rc = vfs_write(fd, &pos, &note, sizeof(elf_note_t));
-	if (rc != sizeof(elf_note_t)) {
+	rc = vfs_write(fd, &pos, &note, sizeof(elf_note_t), &nwr);
+	if (rc != EOK) {
 		printf("Failed writing note header.\n");
 		free(p_hdr);
@@ -238,6 +239,6 @@
 	}
 
-	rc = vfs_write(fd, &pos, "CORE", note.namesz);
-	if (rc != (ssize_t) note.namesz) {
+	rc = vfs_write(fd, &pos, "CORE", note.namesz, &nwr);
+	if (rc != EOK) {
 		printf("Failed writing note header.\n");
 		free(p_hdr);
@@ -247,6 +248,6 @@
 	pos = ALIGN_UP(pos, word_size);
 
-	rc = vfs_write(fd, &pos, &pr_status, sizeof(elf_prstatus_t));
-	if (rc != sizeof(elf_prstatus_t)) {
+	rc = vfs_write(fd, &pos, &pr_status, sizeof(elf_prstatus_t), &nwr);
+	if (rc != EOK) {
 		printf("Failed writing register data.\n");
 		free(p_hdr);
@@ -296,5 +297,6 @@
 	size_t total;
 	uintptr_t addr;
-	ssize_t rc;
+	int rc;
+	size_t nwr;
 
 	addr = area->start_addr;
@@ -309,6 +311,6 @@
 		}
 
-		rc = vfs_write(fd, pos, buffer, to_copy);
-		if (rc != (ssize_t) to_copy) {
+		rc = vfs_write(fd, pos, buffer, to_copy, &nwr);
+		if (rc != EOK) {
 			printf("Failed writing memory contents.\n");
 			return EIO;
Index: uspace/app/taskdump/symtab.c
===================================================================
--- uspace/app/taskdump/symtab.c	(revision 40feeac3d6d981d671abe77b20b3aa999c586faf)
+++ uspace/app/taskdump/symtab.c	(revision 8e3498b351ae109f7ad16592a1f108e3bd44c829)
@@ -71,4 +71,5 @@
 	int fd;
 	int rc;
+	size_t nread;
 	int i;
 
@@ -88,6 +89,6 @@
 	}
 
-	rc = vfs_read(fd, &pos, &elf_hdr, sizeof(elf_header_t));
-	if (rc != sizeof(elf_header_t)) {
+	rc = vfs_read(fd, &pos, &elf_hdr, sizeof(elf_header_t), &nread);
+	if (rc != EOK || nread != sizeof(elf_header_t)) {
 		printf("failed reading elf header\n");
 		free(stab);
@@ -304,8 +305,9 @@
 {
 	int rc;
+	size_t nread;
 	aoff64_t pos = elf_hdr->e_shoff + idx * sizeof(elf_section_header_t);
 
-	rc = vfs_read(fd, &pos, sec_hdr, sizeof(elf_section_header_t));
-	if (rc != sizeof(elf_section_header_t))
+	rc = vfs_read(fd, &pos, sec_hdr, sizeof(elf_section_header_t), &nread);
+	if (rc != EOK || nread != sizeof(elf_section_header_t))
 		return EIO;
 
@@ -326,5 +328,6 @@
 static int chunk_load(int fd, off64_t start, size_t size, void **ptr)
 {
-	ssize_t rc;
+	int rc;
+	size_t nread;
 	aoff64_t pos = start;
 
@@ -335,6 +338,6 @@
 	}
 
-	rc = vfs_read(fd, &pos, *ptr, size);
-	if (rc != (ssize_t) size) {
+	rc = vfs_read(fd, &pos, *ptr, size, &nread);
+	if (rc != EOK || nread != size) {
 		printf("failed reading chunk\n");
 		free(*ptr);
Index: uspace/app/tester/mm/pager1.c
===================================================================
--- uspace/app/tester/mm/pager1.c	(revision 40feeac3d6d981d671abe77b20b3aa999c586faf)
+++ uspace/app/tester/mm/pager1.c	(revision 8e3498b351ae109f7ad16592a1f108e3bd44c829)
@@ -44,4 +44,7 @@
 static void *create_paged_area(size_t size)
 {
+	size_t nwr;
+	int rc;
+
 	TPRINTF("Creating temporary file...\n");
 
@@ -52,5 +55,6 @@
 	(void) vfs_unlink_path(TEST_FILE);
 
-	if (vfs_write(fd, (aoff64_t []) {0}, text, sizeof(text)) < 0) {
+	rc = vfs_write(fd, (aoff64_t []) {0}, text, sizeof(text), &nwr);
+	if (rc != EOK) {
 		vfs_put(fd);
 		return NULL;
Index: uspace/app/tester/vfs/vfs1.c
===================================================================
--- uspace/app/tester/vfs/vfs1.c	(revision 40feeac3d6d981d671abe77b20b3aa999c586faf)
+++ uspace/app/tester/vfs/vfs1.c	(revision 8e3498b351ae109f7ad16592a1f108e3bd44c829)
@@ -84,6 +84,7 @@
 	
 	size_t size = sizeof(text);
-	ssize_t cnt = vfs_write(fd0, &pos, text, size);
-	if (cnt < 0)
+	size_t cnt;
+	rc  = vfs_write(fd0, &pos, text, size, &cnt);
+	if (rc != EOK)
 		return "write() failed";
 	TPRINTF("Written %zd bytes\n", cnt);
@@ -93,15 +94,15 @@
 	char buf[BUF_SIZE];
 	TPRINTF("read..\n");
-	while ((cnt = vfs_read(fd0, &pos, buf, BUF_SIZE))) {
-		TPRINTF("read returns %zd\n", cnt);
-		if (cnt < 0)
+	while ((rc = vfs_read(fd0, &pos, buf, BUF_SIZE, &cnt))) {
+		TPRINTF("read returns rc = %d, cnt = %zu\n", rc, cnt);
+		if (rc != EOK)
 			return "read() failed";
 		
-		int _cnt = (int) cnt;
-		if (_cnt != cnt) {
+		int icnt = (int) cnt;
+		if ((size_t) icnt != cnt) {
 			/* Count overflow, just to be sure. */
 			TPRINTF("Read %zd bytes\n", cnt);
 		} else {
-			TPRINTF("Read %zd bytes: \"%.*s\"\n", cnt, _cnt, buf);
+			TPRINTF("Read %zd bytes: \"%.*s\"\n", cnt, icnt, buf);
 		}
 	}
Index: uspace/app/viewer/viewer.c
===================================================================
--- uspace/app/viewer/viewer.c	(revision 40feeac3d6d981d671abe77b20b3aa999c586faf)
+++ uspace/app/viewer/viewer.c	(revision 8e3498b351ae109f7ad16592a1f108e3bd44c829)
@@ -126,6 +126,7 @@
 	}
 
-	ssize_t rd = vfs_read(fd, (aoff64_t []) {0}, tga, stat.size);
-	if ((rd < 0) || (rd != (ssize_t) stat.size)) {
+	size_t nread;
+	rc = vfs_read(fd, (aoff64_t []) {0}, tga, stat.size, &nread);
+	if (rc != EOK || nread != stat.size) {
 		free(tga);
 		vfs_put(fd);
Index: uspace/app/websrv/websrv.c
===================================================================
--- uspace/app/websrv/websrv.c	(revision 40feeac3d6d981d671abe77b20b3aa999c586faf)
+++ uspace/app/websrv/websrv.c	(revision 8e3498b351ae109f7ad16592a1f108e3bd44c829)
@@ -247,4 +247,5 @@
 	char *fname = NULL;
 	int rc;
+	size_t nr;
 	int fd = -1;
 	
@@ -279,12 +280,10 @@
 	aoff64_t pos = 0;
 	while (true) {
-		ssize_t nr = vfs_read(fd, &pos, fbuf, BUFFER_SIZE);
+		rc = vfs_read(fd, &pos, fbuf, BUFFER_SIZE, &nr);
+		if (rc != EOK)
+			goto out;
+		
 		if (nr == 0)
 			break;
-		
-		if (nr < 0) {
-			rc = EIO;
-			goto out;
-		}
 		
 		rc = tcp_conn_send(conn, fbuf, nr);
Index: uspace/drv/bus/isa/isa.c
===================================================================
--- uspace/drv/bus/isa/isa.c	(revision 40feeac3d6d981d671abe77b20b3aa999c586faf)
+++ uspace/drv/bus/isa/isa.c	(revision 8e3498b351ae109f7ad16592a1f108e3bd44c829)
@@ -277,5 +277,6 @@
 	int fd;
 	size_t len;
-	ssize_t r;
+	int rc;
+	size_t nread;
 	struct stat st;
 
@@ -306,11 +307,11 @@
 	}
 
-	r = vfs_read(fd, (aoff64_t []) {0}, buf, len);
-	if (r < 0) {
+	rc = vfs_read(fd, (aoff64_t []) {0}, buf, len, &nread);
+	if (rc != EOK) {
 		ddf_msg(LVL_ERROR, "Unable to read file '%s'.", conf_path);
 		goto cleanup;
 	}
 
-	buf[len] = 0;
+	buf[nread] = 0;
 
 	suc = true;
Index: uspace/lib/bithenge/src/file.c
===================================================================
--- uspace/lib/bithenge/src/file.c	(revision 40feeac3d6d981d671abe77b20b3aa999c586faf)
+++ uspace/lib/bithenge/src/file.c	(revision 8e3498b351ae109f7ad16592a1f108e3bd44c829)
@@ -77,6 +77,7 @@
 		return ELIMIT;
 
-	ssize_t amount_read = vfs_read(blob->fd, &offset, buffer, *size);
-	if (amount_read < 0)
+	size_t amount_read;
+	int rc = vfs_read(blob->fd, &offset, buffer, *size, &amount_read);
+	if (rc != EOK)
 		return errno;
 	*size += amount_read;
Index: uspace/lib/c/generic/elf/elf_mod.c
===================================================================
--- uspace/lib/c/generic/elf/elf_mod.c	(revision 40feeac3d6d981d671abe77b20b3aa999c586faf)
+++ uspace/lib/c/generic/elf/elf_mod.c	(revision 8e3498b351ae109f7ad16592a1f108e3bd44c829)
@@ -137,8 +137,9 @@
 	elf_header_t *header = &header_buf;
 	aoff64_t pos = 0;
+	size_t nr;
 	int i, rc;
 
-	rc = vfs_read(elf->fd, &pos, header, sizeof(elf_header_t));
-	if (rc != sizeof(elf_header_t)) {
+	rc = vfs_read(elf->fd, &pos, header, sizeof(elf_header_t), &nr);
+	if (rc != EOK || nr != sizeof(elf_header_t)) {
 		DPRINTF("Read error.\n"); 
 		return EE_INVALID;
@@ -199,6 +200,6 @@
 		pos = header->e_phoff + i * sizeof(elf_segment_header_t);
 		rc = vfs_read(elf->fd, &pos, &segment_hdr,
-		    sizeof(elf_segment_header_t));
-		if (rc != sizeof(elf_segment_header_t)) {
+		    sizeof(elf_segment_header_t), &nr);
+		if (rc != EOK || nr != sizeof(elf_segment_header_t)) {
 			DPRINTF("Read error.\n");
 			return EE_INVALID;
@@ -218,6 +219,6 @@
 		pos = header->e_shoff + i * sizeof(elf_section_header_t);
 		rc = vfs_read(elf->fd, &pos, &section_hdr,
-		    sizeof(elf_section_header_t));
-		if (rc != sizeof(elf_section_header_t)) {
+		    sizeof(elf_section_header_t), &nr);
+		if (rc != EOK || nr != sizeof(elf_section_header_t)) {
 			DPRINTF("Read error.\n");
 			return EE_INVALID;
@@ -330,5 +331,6 @@
 	size_t mem_sz;
 	aoff64_t pos;
-	ssize_t rc;
+	int rc;
+	size_t nr;
 
 	bias = elf->bias;
@@ -388,6 +390,6 @@
 	 */
 	pos = entry->p_offset;
-	rc = vfs_read(elf->fd, &pos, seg_ptr, entry->p_filesz);
-	if (rc < 0) {
+	rc = vfs_read(elf->fd, &pos, seg_ptr, entry->p_filesz, &nr);
+	if (rc != EOK || nr != entry->p_filesz) {
 		DPRINTF("read error\n");
 		return EE_INVALID;
Index: uspace/lib/c/generic/io/io.c
===================================================================
--- uspace/lib/c/generic/io/io.c	(revision 40feeac3d6d981d671abe77b20b3aa999c586faf)
+++ uspace/lib/c/generic/io/io.c	(revision 8e3498b351ae109f7ad16592a1f108e3bd44c829)
@@ -430,17 +430,19 @@
 static size_t _fread(void *buf, size_t size, size_t nmemb, FILE *stream)
 {
+	int rc;
+	size_t nread;
+
 	if (size == 0 || nmemb == 0)
 		return 0;
 
-	ssize_t rd = vfs_read(stream->fd, &stream->pos, buf, size * nmemb);
-	if (rd < 0) {
-		errno = rd;
+	rc = vfs_read(stream->fd, &stream->pos, buf, size * nmemb, &nread);
+	if (rc != EOK) {
+		errno = rc;
 		stream->error = true;
-		rd = 0;
-	} else if (rd == 0) {
+	} else if (nread == 0) {
 		stream->eof = true;
 	}
-	
-	return (rd / size);
+
+	return (nread / size);
 }
 
@@ -457,30 +459,29 @@
 static size_t _fwrite(const void *buf, size_t size, size_t nmemb, FILE *stream)
 {
+	int rc;
+	size_t nwritten;
+
 	if (size == 0 || nmemb == 0)
 		return 0;
 
-	ssize_t wr;
 	if (stream->kio) {
-		size_t nwritten;
-		wr = kio_write(buf, size * nmemb, &nwritten);
-		if (wr != EOK) {
+		rc = kio_write(buf, size * nmemb, &nwritten);
+		if (rc != EOK) {
 			stream->error = true;
-			wr = 0;
-		} else {
-			wr = nwritten;
+			nwritten = 0;
 		}
 	} else {
-		wr = vfs_write(stream->fd, &stream->pos, buf, size * nmemb);
-		if (wr < 0) {
-			errno = wr;
+		rc = vfs_write(stream->fd, &stream->pos, buf, size * nmemb,
+		    &nwritten);
+		if (rc != EOK) {
+			errno = rc;
 			stream->error = true;
-			wr = 0;
 		}
 	}
 
-	if (wr > 0)
+	if (nwritten > 0)
 		stream->need_sync = true;
-	
-	return (wr / size);
+
+	return (nwritten / size);
 }
 
@@ -491,10 +492,12 @@
 static void _ffillbuf(FILE *stream)
 {
-	ssize_t rc;
+	int rc;
+	size_t nread;
 
 	stream->buf_head = stream->buf_tail = stream->buf;
 
-	rc = vfs_read(stream->fd, &stream->pos, stream->buf, stream->buf_size);
-	if (rc < 0) {
+	rc = vfs_read(stream->fd, &stream->pos, stream->buf, stream->buf_size,
+	    &nread);
+	if (rc != EOK) {
 		errno = rc;
 		stream->error = true;
@@ -502,10 +505,10 @@
 	}
 
-	if (rc == 0) {
+	if (nread == 0) {
 		stream->eof = true;
 		return;
 	}
 
-	stream->buf_head += rc;
+	stream->buf_head += nread;
 	stream->buf_state = _bs_read;
 }
Index: uspace/lib/c/generic/vfs/vfs.c
===================================================================
--- uspace/lib/c/generic/vfs/vfs.c	(revision 40feeac3d6d981d671abe77b20b3aa999c586faf)
+++ uspace/lib/c/generic/vfs/vfs.c	(revision 8e3498b351ae109f7ad16592a1f108e3bd44c829)
@@ -86,5 +86,5 @@
  * and consume system resources.
  *
- * Functions that return int return a negative error code on error and do not
+ * Functions that return int return an error code on error and do not
  * set errno. Depending on function, success is signalled by returning either
  * EOK or a non-negative file handle.
@@ -104,11 +104,12 @@
  * 	aoff64_t pos = 42;
  * 	char buf[512];
- * 	ssize_t size = vfs_read(file, &pos, buf, sizeof(buf));
- * 	if (size < 0) {
+ *	size_t nread;
+ * 	rc = vfs_read(file, &pos, buf, sizeof(buf), &nread);
+ * 	if (rc != EOK) {
  * 		vfs_put(file);
- * 		return size;
+ * 		return rc;
  * 	}
  *
- *	// buf is now filled with data from file
+ *	// buf is now filled with nread bytes from file
  *
  *	vfs_put(file);
@@ -808,12 +809,14 @@
  * @param buf		Buffer, @a nbytes bytes long
  * @param nbytes	Number of bytes to read
- *
- * @return              On success, non-negative number of bytes read
- * @return              On failure, a negative error code
- */
-ssize_t vfs_read(int file, aoff64_t *pos, void *buf, size_t nbyte)
+ * @param nread		Place to store number of bytes actually read
+ *
+ * @return              On success, EOK and @a *nread is filled with number
+ *			of bytes actually read.
+ * @return              On failure, an error code
+ */
+int vfs_read(int file, aoff64_t *pos, void *buf, size_t nbyte, size_t *nread)
 {
 	ssize_t cnt = 0;
-	size_t nread = 0;
+	size_t nr = 0;
 	uint8_t *bp = (uint8_t *) buf;
 	int rc;
@@ -821,14 +824,18 @@
 	do {
 		bp += cnt;
-		nread += cnt;
+		nr += cnt;
 		*pos += cnt;
-		rc = vfs_read_short(file, *pos, bp, nbyte - nread, &cnt);
-	} while (rc == EOK && cnt > 0 && (nbyte - nread - cnt) > 0);
-	
-	if (rc != EOK)
+		rc = vfs_read_short(file, *pos, bp, nbyte - nr, &cnt);
+	} while (rc == EOK && cnt > 0 && (nbyte - nr - cnt) > 0);
+	
+	if (rc != EOK) {
+		*nread = nr;
 		return rc;
-	
+	}
+	
+	nr += cnt;
 	*pos += cnt;
-	return nread + cnt;
+	*nread = nr;
+	return EOK;
 }
 
@@ -1247,12 +1254,15 @@
  * @param buf           Data, @a nbytes bytes long
  * @param nbytes        Number of bytes to write
- *
- * @return		On success, non-negative number of bytes written
- * @return              On failure, a negative error code
- */
-ssize_t vfs_write(int file, aoff64_t *pos, const void *buf, size_t nbyte)
+ * @param nwritten	Place to store number of bytes written
+ *
+ * @return		On success, EOK, @a *nwr is filled with number
+ *			of bytes written
+ * @return              On failure, an error code
+ */
+int vfs_write(int file, aoff64_t *pos, const void *buf, size_t nbyte,
+    size_t *nwritten)
 {
 	ssize_t cnt = 0;
-	ssize_t nwritten = 0;
+	ssize_t nwr = 0;
 	const uint8_t *bp = (uint8_t *) buf;
 	int rc;
@@ -1260,14 +1270,18 @@
 	do {
 		bp += cnt;
-		nwritten += cnt;
+		nwr += cnt;
 		*pos += cnt;
-		rc = vfs_write_short(file, *pos, bp, nbyte - nwritten, &cnt);
-	} while (rc == EOK && ((ssize_t )nbyte - nwritten - cnt) > 0);
-
-	if (rc != EOK)
+		rc = vfs_write_short(file, *pos, bp, nbyte - nwr, &cnt);
+	} while (rc == EOK && ((ssize_t )nbyte - nwr - cnt) > 0);
+
+	if (rc != EOK) {
+		*nwritten = nwr;
 		return rc;
-
+	}
+
+	nwr += cnt;
 	*pos += cnt;
-	return nbyte;
+	*nwritten = nwr;
+	return EOK;
 }
 
Index: uspace/lib/c/include/vfs/vfs.h
===================================================================
--- uspace/lib/c/include/vfs/vfs.h	(revision 40feeac3d6d981d671abe77b20b3aa999c586faf)
+++ uspace/lib/c/include/vfs/vfs.h	(revision 8e3498b351ae109f7ad16592a1f108e3bd44c829)
@@ -104,5 +104,5 @@
 extern int vfs_pass_handle(async_exch_t *, int, async_exch_t *);
 extern int vfs_put(int);
-extern ssize_t vfs_read(int, aoff64_t *, void *, size_t);
+extern int vfs_read(int, aoff64_t *, void *, size_t, size_t *);
 extern int vfs_read_short(int, aoff64_t, void *, size_t, ssize_t *);
 extern int vfs_receive_handle(bool);
@@ -121,5 +121,5 @@
 extern int vfs_unmount_path(const char *);
 extern int vfs_walk(int, const char *, int);
-extern ssize_t vfs_write(int, aoff64_t *, const void *, size_t);
+extern int vfs_write(int, aoff64_t *, const void *, size_t, size_t *);
 extern int vfs_write_short(int, aoff64_t, const void *, size_t, ssize_t *);
 
Index: uspace/lib/pcut/src/os/helenos.c
===================================================================
--- uspace/lib/pcut/src/os/helenos.c	(revision 40feeac3d6d981d671abe77b20b3aa999c586faf)
+++ uspace/lib/pcut/src/os/helenos.c	(revision 8e3498b351ae109f7ad16592a1f108e3bd44c829)
@@ -213,5 +213,6 @@
 
 	aoff64_t pos = 0;
-	vfs_read(tempfile, &pos, extra_output_buffer, OUTPUT_BUFFER_SIZE);
+	size_t nread;
+	vfs_read(tempfile, &pos, extra_output_buffer, OUTPUT_BUFFER_SIZE, &nread);
 
 leave_close_tempfile:
Index: uspace/lib/posix/source/stdio.c
===================================================================
--- uspace/lib/posix/source/stdio.c	(revision 40feeac3d6d981d671abe77b20b3aa999c586faf)
+++ uspace/lib/posix/source/stdio.c	(revision 8e3498b351ae109f7ad16592a1f108e3bd44c829)
@@ -343,7 +343,8 @@
 {
 	const int fildes = *(int *) fd;
-	ssize_t wr = vfs_write(fildes, &posix_pos[fildes], str, size);
-	if (wr < 0)
-		return wr;
+	size_t wr;
+	int rc = vfs_write(fildes, &posix_pos[fildes], str, size, &wr);
+	if (rc != EOK)
+		return rc;
 	return str_nlength(str, wr);
 }
@@ -371,5 +372,6 @@
 		
 		const int fildes = *(int *) fd;
-		if (vfs_write(fildes, &posix_pos[fildes], buf, sz) < 0)
+		size_t nwr;
+		if (vfs_write(fildes, &posix_pos[fildes], buf, sz, &nwr) != EOK)
 			break;
 		
Index: uspace/lib/posix/source/unistd.c
===================================================================
--- uspace/lib/posix/source/unistd.c	(revision 40feeac3d6d981d671abe77b20b3aa999c586faf)
+++ uspace/lib/posix/source/unistd.c	(revision 8e3498b351ae109f7ad16592a1f108e3bd44c829)
@@ -213,8 +213,11 @@
 ssize_t posix_read(int fildes, void *buf, size_t nbyte)
 {
-	ssize_t size = rcerrno(vfs_read, fildes, &posix_pos[fildes], buf, nbyte);
-	if (size < 0)
-		return -1;
-	return size;
+	size_t nread;
+	int rc;
+
+	rc = rcerrno(vfs_read, fildes, &posix_pos[fildes], buf, nbyte, &nread);
+	if (rc != EOK)
+		return -1;
+	return (ssize_t) nread;
 }
 
@@ -229,8 +232,11 @@
 ssize_t posix_write(int fildes, const void *buf, size_t nbyte)
 {
-	ssize_t size = rcerrno(vfs_write, fildes, &posix_pos[fildes], buf, nbyte);
-	if (size < 0)
-		return -1;
-	return size;
+	size_t nwr;
+	int rc;
+
+	rc = rcerrno(vfs_write, fildes, &posix_pos[fildes], buf, nbyte, &nwr);
+	if (rc != EOK)
+		return -1;
+	return nwr;
 }
 
Index: uspace/srv/devman/match.c
===================================================================
--- uspace/srv/devman/match.c	(revision 40feeac3d6d981d671abe77b20b3aa999c586faf)
+++ uspace/srv/devman/match.c	(revision 8e3498b351ae109f7ad16592a1f108e3bd44c829)
@@ -229,6 +229,7 @@
 	}
 	
-	ssize_t read_bytes = vfs_read(fd, (aoff64_t []) {0}, buf, len);
-	if (read_bytes <= 0) {
+	size_t read_bytes;
+	int rc = vfs_read(fd, (aoff64_t []) {0}, buf, len, &read_bytes);
+	if (rc != EOK) {
 		log_msg(LOG_DEFAULT, LVL_ERROR, "Unable to read file '%s' (%d).", conf_path,
 		    errno);