Changeset 04803bf in mainline for uspace/lib/c/generic/io/io.c

Timestamp:

2011-03-21T22:00:17Z (15 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

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

Children:

143932e3

Parents:

b50b5af2 (diff), 7308e84 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge mainline changes (needs fixes).

File:

• uspace/lib/c/generic/io/io.c (moved) (moved from uspace/lib/libc/generic/io/io.c ) (22 diffs)

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

@@ -37 +37 @@
 #include <fcntl.h>
 #include <assert.h>
-#include <string.h>
+#include <str.h>
 #include <errno.h>
 #include <bool.h>
 #include <malloc.h>
+#include <async.h>
 #include <io/klog.h>
 #include <vfs/vfs.h>
 #include <ipc/devmap.h>
 #include <adt/list.h>
-
+#include "../private/io.h"
+
+static void _ffillbuf(FILE *stream);
 static void _fflushbuf(FILE *stream);
 
@@ -57 +60 @@
         .buf = NULL,
         .buf_size = 0,
-        .buf_head = NULL
+        .buf_head = NULL,
+        .buf_tail = NULL,
+        .buf_state = _bs_empty
 };
 
@@ -69 +74 @@
         .buf = NULL,
         .buf_size = BUFSIZ,
-        .buf_head = NULL
+        .buf_head = NULL,
+        .buf_tail = NULL,
+        .buf_state = _bs_empty
 };
 
@@ -81 +88 @@
         .buf = NULL,
         .buf_size = 0,
-        .buf_head = NULL
+        .buf_head = NULL,
+        .buf_tail = NULL,
+        .buf_state = _bs_empty
 };
 
@@ -179 +188 @@
         stream->buf_size = size;
         stream->buf_head = stream->buf;
+        stream->buf_tail = stream->buf;
+        stream->buf_state = _bs_empty;
 }
 
@@ -210 +221 @@
         
         stream->buf_head = stream->buf;
+        stream->buf_tail = stream->buf;
         return 0;
 }
@@ -243 +255 @@
         stream->klog = false;
         stream->phone = -1;
+        stream->need_sync = false;
         _setvbuf(stream);
         
@@ -264 +277 @@
         stream->klog = false;
         stream->phone = -1;
+        stream->need_sync = false;
         _setvbuf(stream);
         
@@ -295 +309 @@
         stream->klog = false;
         stream->phone = -1;
+        stream->need_sync = false;
         _setvbuf(stream);
         
@@ -309 +324 @@
         
         if (stream->phone >= 0)
-                ipc_hangup(stream->phone);
+                async_hangup(stream->phone);
         
         if (stream->fd >= 0)
@@ -331 +346 @@
 }
 
-/** Read from a stream.
+/** Read from a stream (unbuffered).
  *
  * @param buf    Destination buffer.
@@ -337 +352 @@
  * @param nmemb  Number of records to read.
  * @param stream Pointer to the stream.
- *
- */
-size_t fread(void *buf, size_t size, size_t nmemb, FILE *stream)
-{
-        size_t left = size * nmemb;
-        size_t done = 0;
-        
-        /* Make sure no data is pending write. */
-        _fflushbuf(stream);
+ */
+static size_t _fread(void *buf, size_t size, size_t nmemb, FILE *stream)
+{
+        size_t left, done;
+
+        if (size == 0 || nmemb == 0)
+                return 0;
+
+        left = size * nmemb;
+        done = 0;
         
         while ((left > 0) && (!stream->error) && (!stream->eof)) {
@@ -363 +379 @@
 }
 
+/** Write to a stream (unbuffered).
+ *
+ * @param buf    Source buffer.
+ * @param size   Size of each record.
+ * @param nmemb  Number of records to write.
+ * @param stream Pointer to the stream.
+ */
 static size_t _fwrite(const void *buf, size_t size, size_t nmemb, FILE *stream)
 {
-        size_t left = size * nmemb;
-        size_t done = 0;
-        
+        size_t left;
+        size_t done;
+
+        if (size == 0 || nmemb == 0)
+                return 0;
+
+        left = size * nmemb;
+        done = 0;
+
         while ((left > 0) && (!stream->error)) {
                 ssize_t wr;
@@ -383 +412 @@
                 }
         }
+
+        if (done > 0)
+                stream->need_sync = true;
         
         return (done / size);
 }
 
-/** Drain stream buffer, do not sync stream. */
+/** Read some data in stream buffer. */
+static void _ffillbuf(FILE *stream)
+{
+        ssize_t rc;
+
+        stream->buf_head = stream->buf_tail = stream->buf;
+
+        rc = read(stream->fd, stream->buf, stream->buf_size);
+        if (rc < 0) {
+                stream->error = true;
+                return;
+        }
+
+        if (rc == 0) {
+                stream->eof = true;
+                return;
+        }
+
+        stream->buf_head += rc;
+        stream->buf_state = _bs_read;
+}
+
+/** Write out stream buffer, do not sync stream. */
 static void _fflushbuf(FILE *stream)
 {
         size_t bytes_used;
-        
+
         if ((!stream->buf) || (stream->btype == _IONBF) || (stream->error))
                 return;
-        
-        bytes_used = stream->buf_head - stream->buf;
+
+        bytes_used = stream->buf_head - stream->buf_tail;
         if (bytes_used == 0)
                 return;
-        
-        (void) _fwrite(stream->buf, 1, bytes_used, stream);
+
+        /* If buffer has prefetched read data, we need to seek back. */
+        if (stream->buf_state == _bs_read)
+                lseek(stream->fd, - (ssize_t) bytes_used, SEEK_CUR);
+
+        /* If buffer has unwritten data, we need to write them out. */
+        if (stream->buf_state == _bs_write)
+                (void) _fwrite(stream->buf_tail, 1, bytes_used, stream);
+
         stream->buf_head = stream->buf;
-}
+        stream->buf_tail = stream->buf;
+        stream->buf_state = _bs_empty;
+}
+
+/** Read from a stream.
+ *
+ * @param dest   Destination buffer.
+ * @param size   Size of each record.
+ * @param nmemb  Number of records to read.
+ * @param stream Pointer to the stream.
+ *
+ */
+size_t fread(void *dest, size_t size, size_t nmemb, FILE *stream)
+{
+        uint8_t *dp;
+        size_t bytes_left;
+        size_t now;
+        size_t data_avail;
+        size_t total_read;
+        size_t i;
+
+        if (size == 0 || nmemb == 0)
+                return 0;
+
+        /* If not buffered stream, read in directly. */
+        if (stream->btype == _IONBF) {
+                now = _fread(dest, size, nmemb, stream);
+                return now;
+        }
+
+        /* Make sure no data is pending write. */
+        if (stream->buf_state == _bs_write)
+                _fflushbuf(stream);
+
+        /* Perform lazy allocation of stream buffer. */
+        if (stream->buf == NULL) {
+                if (_fallocbuf(stream) != 0)
+                        return 0; /* Errno set by _fallocbuf(). */
+        }
+
+        bytes_left = size * nmemb;
+        total_read = 0;
+        dp = (uint8_t *) dest;
+
+        while ((!stream->error) && (!stream->eof) && (bytes_left > 0)) {
+                if (stream->buf_head == stream->buf_tail)
+                        _ffillbuf(stream);
+
+                if (stream->error || stream->eof)
+                        break;
+
+                data_avail = stream->buf_head - stream->buf_tail;
+
+                if (bytes_left > data_avail)
+                        now = data_avail;
+                else
+                        now = bytes_left;
+
+                for (i = 0; i < now; i++) {
+                        dp[i] = stream->buf_tail[i];
+                }
+
+                dp += now;
+                stream->buf_tail += now;
+                bytes_left -= now;
+                total_read += now;
+        }
+
+        return (total_read / size);
+}
+
 
 /** Write to a stream.
@@ -421 +552 @@
         uint8_t b;
         bool need_flush;
-        
+
+        if (size == 0 || nmemb == 0)
+                return 0;
+
         /* If not buffered stream, write out directly. */
         if (stream->btype == _IONBF) {
@@ -428 +562 @@
                 return now;
         }
-        
+
+        /* Make sure buffer contains no prefetched data. */
+        if (stream->buf_state == _bs_read)
+                _fflushbuf(stream);
+
+
         /* Perform lazy allocation of stream buffer. */
         if (stream->buf == NULL) {
@@ -468 +607 @@
         }
         
+        if (total_written > 0)
+                stream->buf_state = _bs_write;
+
         if (need_flush)
                 fflush(stream);
@@ -480 +622 @@
         
         if (chr_encode(c, buf, &sz, STR_BOUNDS(1)) == EOK) {
-                size_t wr = fwrite(buf, sz, 1, stream);
+                size_t wr = fwrite(buf, 1, sz, stream);
                 
                 if (wr < sz)
@@ -522 +664 @@
 }
 
+char *fgets(char *str, int size, FILE *stream)
+{
+        int c;
+        int idx;
+
+        idx = 0;
+        while (idx < size - 1) {
+                c = fgetc(stream);
+                if (c == EOF)
+                        break;
+
+                str[idx++] = c;
+
+                if (c == '\n')
+                        break;
+        }
+
+        if (ferror(stream))
+                return NULL;
+
+        if (idx == 0)
+                return NULL;
+
+        str[idx] = '\0';
+        return str;
+}
+
 int getchar(void)
 {
@@ -527 +696 @@
 }
 
-int fseek(FILE *stream, long offset, int origin)
-{
-        off_t rc = lseek(stream->fd, offset, origin);
-        if (rc == (off_t) (-1)) {
-                /* errno has been set by lseek. */
+int fseek(FILE *stream, off64_t offset, int whence)
+{
+        off64_t rc;
+
+        _fflushbuf(stream);
+
+        rc = lseek(stream->fd, offset, whence);
+        if (rc == (off64_t) (-1)) {
+                /* errno has been set by lseek64. */
                 return -1;
         }
-        
+
         stream->eof = false;
-        
         return 0;
+}
+
+off64_t ftell(FILE *stream)
+{
+        return lseek(stream->fd, 0, SEEK_CUR);
 }
 
@@ -554 +731 @@
         }
         
-        if (stream->fd >= 0)
+        if (stream->fd >= 0 && stream->need_sync) {
+                /**
+                 * Better than syncing always, but probably still not the
+                 * right thing to do.
+                 */
+                stream->need_sync = false;
                 return fsync(stream->fd);
+        }
         
         return ENOENT;
@@ -568 +751 @@
 {
         return stream->error;
+}
+
+void clearerr(FILE *stream)
+{
+        stream->eof = false;
+        stream->error = false;
+}
+
+int fileno(FILE *stream)
+{
+        if (stream->klog) {
+                errno = EBADF;
+                return -1;
+        }
+        
+        return stream->fd;
 }