Changeset 6afc9d7 in mainline for uspace/lib/c/generic/io/io.c

Timestamp:

2015-10-06T19:01:36Z (9 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

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

Children:

0328987

Parents:

f1f7584

Message:

UNIX-like I/O functions should use errno to return error code for many reasons.

File:

• uspace/lib/c/generic/io/io.c (modified) (19 diffs)

uspace/lib/c/generic/io/io.c

@@ -231 +231 @@
         if (stream->buf == NULL) {
                 errno = ENOMEM;
-                return -1;
+                return EOF;
         }
         
@@ -365 +365 @@
  * @param nmemb  Number of records to read.
  * @param stream Pointer to the stream.
+ *
+ * @return Number of elements successfully read. On error this is less than
+ *         nmemb, stream error indicator is set and errno is set.
  */
 static size_t _fread(void *buf, size_t size, size_t nmemb, FILE *stream)
@@ -379 +382 @@
                 ssize_t rd = read(stream->fd, buf + done, left);
                 
-                if (rd < 0)
+                if (rd < 0) {
+                        /* errno was set by read() */
                         stream->error = true;
-                else if (rd == 0)
+                } else if (rd == 0) {
                         stream->eof = true;
-                else {
+                } else {
                         left -= rd;
                         done += rd;
@@ -398 +402 @@
  * @param nmemb  Number of records to write.
  * @param stream Pointer to the stream.
+ *
+ * @return Number of elements successfully written. On error this is less than
+ *         nmemb, stream error indicator is set and errno is set.
  */
 static size_t _fwrite(const void *buf, size_t size, size_t nmemb, FILE *stream)
@@ -403 +410 @@
         size_t left;
         size_t done;
+        int rc;
 
         if (size == 0 || nmemb == 0)
@@ -412 +420 @@
         while ((left > 0) && (!stream->error)) {
                 ssize_t wr;
+                size_t uwr;
                 
-                if (stream->kio)
-                        wr = kio_write(buf + done, left);
-                else
+                if (stream->kio) {
+                        uwr = 0;
+                        rc = kio_write(buf + done, left, &uwr);
+                        if (rc != EOK)
+                                errno = rc;
+                } else {
                         wr = write(stream->fd, buf + done, left);
+                        if (wr >= 0) {
+                                uwr = (size_t)wr;
+                                rc = EOK;
+                        } else {
+                                /* errno was set by write */
+                                uwr = 0;
+                                rc = errno;
+                        }
+                }
                 
-                if (wr <= 0)
+                if (rc != EOK) {
+                        /* errno was set above */
                         stream->error = true;
-                else {
-                        left -= wr;
-                        done += wr;
+                } else {
+                        left -= uwr;
+                        done += uwr;
                 }
         }
@@ -432 +454 @@
 }
 
-/** Read some data in stream buffer. */
+/** Read some data in stream buffer.
+ *
+ * On error, stream error indicator is set and errno is set.
+ */
 static void _ffillbuf(FILE *stream)
 {
@@ -441 +466 @@
         rc = read(stream->fd, stream->buf, stream->buf_size);
         if (rc < 0) {
+                /* errno was set by read() */
                 stream->error = true;
                 return;
@@ -465 +491 @@
 
         /* If buffer has prefetched read data, we need to seek back. */
-        if (bytes_used > 0 && stream->buf_state == _bs_read)
-                lseek(stream->fd, - (ssize_t) bytes_used, SEEK_CUR);
+        if (bytes_used > 0 && stream->buf_state == _bs_read) {
+                off64_t rc;
+                rc = lseek(stream->fd, - (ssize_t) bytes_used, SEEK_CUR);
+                if (rc == (off64_t)-1) {
+                        /* errno was set by lseek */
+                        stream->error = 1;
+                        return;
+                }
+        }
 
         /* If buffer has unwritten data, we need to write them out. */
-        if (bytes_used > 0 && stream->buf_state == _bs_write)
+        if (bytes_used > 0 && stream->buf_state == _bs_write) {
                 (void) _fwrite(stream->buf_tail, 1, bytes_used, stream);
+                /* On error stream error indicator and errno are set by _fwrite */
+                if (stream->error)
+                        return;
+        }
 
         stream->buf_head = stream->buf;
@@ -528 +565 @@
                         _ffillbuf(stream);
 
-                if (stream->error || stream->eof)
+                if (stream->error || stream->eof) {
+                        /* On error errno was set by _ffillbuf() */
                         break;
+                }
 
                 data_avail = stream->buf_head - stream->buf_tail;
@@ -584 +623 @@
         if (stream->buf_state == _bs_read)
                 _fflushbuf(stream);
-
 
         /* Perform lazy allocation of stream buffer. */
@@ -622 +660 @@
                         /* Only need to drain buffer. */
                         _fflushbuf(stream);
-                        need_flush = false;
+                        if (!stream->error)
+                                need_flush = false;
                 }
         }
@@ -734 +773 @@
         off64_t rc;
 
+        if (stream->error)
+                return EOF;
+
         _fflushbuf(stream);
+        if (stream->error) {
+                /* errno was set by _fflushbuf() */
+                return EOF;
+        }
+
         stream->ungetc_chars = 0;
 
         rc = lseek(stream->fd, offset, whence);
         if (rc == (off64_t) (-1)) {
-                /* errno has been set by lseek64. */
-                return -1;
+                /* errno has been set by lseek() */
+                return EOF;
         }
 
@@ -749 +796 @@
 off64_t ftell(FILE *stream)
 {
+        off64_t pos;
+        
+        if (stream->error)
+                return EOF;
+        
         _fflushbuf(stream);
-        return lseek(stream->fd, 0, SEEK_CUR) - stream->ungetc_chars;
+        if (stream->error) {
+                /* errno was set by _fflushbuf() */
+                return EOF;
+        }
+
+        pos = lseek(stream->fd, 0, SEEK_CUR);
+        if (pos == (off64_t) -1) {
+                /* errno was set by lseek */
+                return (off64_t) -1;
+        }
+        
+        return pos - stream->ungetc_chars;
 }
 
@@ -760 +823 @@
 int fflush(FILE *stream)
 {
+        if (stream->error)
+                return EOF;
+        
         _fflushbuf(stream);
+        if (stream->error) {
+                /* errno was set by _fflushbuf() */
+                return EOF;
+        }
         
         if (stream->kio) {
                 kio_update();
-                return EOK;
+                return 0;
         }
         
@@ -773 +843 @@
                  */
                 stream->need_sync = false;
-                return fsync(stream->fd);
-        }
-        
-        return ENOENT;
+                if (fsync(stream->fd) != 0) {
+                        /* errno was set by fsync() */
+                        return EOF;
+                }
+
+                return 0;
+        }
+        
+        return 0;
 }
 
@@ -799 +874 @@
         if (stream->kio) {
                 errno = EBADF;
-                return -1;
+                return EOF;
         }
         
@@ -805 +880 @@
 }
 
-async_sess_t *fsession(FILE *stream, iface_t iface)
+async_sess_t *vfs_fsession(FILE *stream, iface_t iface)
 {
         if (stream->fd >= 0) {
                 if (stream->sess == NULL)
-                        stream->sess = fd_session(stream->fd, iface);
+                        stream->sess = vfs_fd_session(stream->fd, iface);
                 
                 return stream->sess;
@@ -817 +892 @@
 }
 
-int fhandle(FILE *stream, int *handle)
+int vfs_fhandle(FILE *stream, int *handle)
 {
         if (stream->fd >= 0) {