Fork us on GitHub Follow us on Facebook Follow us on Twitter

Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/c/generic/io/io.c

    red88c8e r01cc7b4  
    5353static void _fflushbuf(FILE *stream);
    5454
     55static size_t stdio_kio_read(void *, size_t, size_t, FILE *);
     56static size_t stdio_kio_write(const void *, size_t, size_t, FILE *);
     57static int stdio_kio_flush(FILE *);
     58
     59static size_t stdio_vfs_read(void *, size_t, size_t, FILE *);
     60static size_t stdio_vfs_write(const void *, size_t, size_t, FILE *);
     61
     62static int stdio_vfs_flush(FILE *);
     63
     64/** KIO stream ops */
     65static __stream_ops_t stdio_kio_ops = {
     66        .read = stdio_kio_read,
     67        .write = stdio_kio_write,
     68        .flush = stdio_kio_flush
     69};
     70
     71/** VFS stream ops */
     72static __stream_ops_t stdio_vfs_ops = {
     73        .read = stdio_vfs_read,
     74        .write = stdio_vfs_write,
     75        .flush = stdio_vfs_flush
     76};
     77
    5578static FILE stdin_null = {
    5679        .fd = -1,
     
    5881        .error = true,
    5982        .eof = true,
    60         .kio = false,
     83        .ops = &stdio_vfs_ops,
     84        .arg = NULL,
    6185        .sess = NULL,
    6286        .btype = _IONBF,
     
    7397        .error = false,
    7498        .eof = false,
    75         .kio = true,
     99        .ops = &stdio_kio_ops,
     100        .arg = NULL,
    76101        .sess = NULL,
    77102        .btype = _IOLBF,
     
    88113        .error = false,
    89114        .eof = false,
    90         .kio = true,
     115        .ops = &stdio_kio_ops,
     116        .arg = NULL,
    91117        .sess = NULL,
    92118        .btype = _IONBF,
     
    328354        stream->error = false;
    329355        stream->eof = false;
    330         stream->kio = false;
     356        stream->ops = &stdio_vfs_ops;
     357        stream->arg = NULL;
    331358        stream->sess = NULL;
    332359        stream->need_sync = false;
     
    352379        stream->error = false;
    353380        stream->eof = false;
    354         stream->kio = false;
     381        stream->ops = &stdio_vfs_ops;
     382        stream->arg = NULL;
    355383        stream->sess = NULL;
    356384        stream->need_sync = false;
     
    435463static size_t _fread(void *buf, size_t size, size_t nmemb, FILE *stream)
    436464{
    437         errno_t rc;
    438         size_t nread;
    439 
    440         if (size == 0 || nmemb == 0)
    441                 return 0;
    442 
    443         rc = vfs_read(stream->fd, &stream->pos, buf, size * nmemb, &nread);
    444         if (rc != EOK) {
    445                 errno = rc;
    446                 stream->error = true;
    447         } else if (nread == 0) {
    448                 stream->eof = true;
    449         }
    450 
    451         return (nread / size);
     465        return stream->ops->read(buf, size, nmemb, stream);
    452466}
    453467
     
    464478static size_t _fwrite(const void *buf, size_t size, size_t nmemb, FILE *stream)
    465479{
    466         errno_t rc;
    467480        size_t nwritten;
    468481
     
    470483                return 0;
    471484
    472         if (stream->kio) {
    473                 rc = kio_write(buf, size * nmemb, &nwritten);
    474                 if (rc != EOK) {
    475                         stream->error = true;
    476                         nwritten = 0;
    477                 }
    478         } else {
    479                 rc = vfs_write(stream->fd, &stream->pos, buf, size * nmemb,
    480                     &nwritten);
    481                 if (rc != EOK) {
    482                         errno = rc;
    483                         stream->error = true;
    484                 }
    485         }
     485        nwritten = stream->ops->write(buf, size, nmemb, stream);
    486486
    487487        if (nwritten > 0)
     
    905905        }
    906906
    907         if (stream->kio) {
    908                 kio_update();
    909                 return 0;
    910         }
    911 
    912         if ((stream->fd >= 0) && (stream->need_sync)) {
    913                 errno_t rc;
    914 
     907        if (stream->need_sync) {
    915908                /**
    916909                 * Better than syncing always, but probably still not the
    917910                 * right thing to do.
    918911                 */
     912                if (stream->ops->flush(stream) == EOF)
     913                        return EOF;
     914
    919915                stream->need_sync = false;
    920                 rc = vfs_sync(stream->fd);
    921                 if (rc != EOK) {
    922                         errno = rc;
    923                         return EOF;
    924                 }
    925 
    926                 return 0;
    927916        }
    928917
     
    948937int fileno(FILE *stream)
    949938{
    950         if (stream->kio) {
     939        if (stream->ops != &stdio_vfs_ops) {
    951940                errno = EBADF;
    952941                return EOF;
     
    978967}
    979968
     969/** Read from KIO stream. */
     970static size_t stdio_kio_read(void *buf, size_t size, size_t nmemb, FILE *stream)
     971{
     972        stream->eof = true;
     973        return 0;
     974}
     975
     976/** Write to KIO stream. */
     977static size_t stdio_kio_write(const void *buf, size_t size, size_t nmemb,
     978    FILE *stream)
     979{
     980        errno_t rc;
     981        size_t nwritten;
     982
     983        rc = kio_write(buf, size * nmemb, &nwritten);
     984        if (rc != EOK) {
     985                stream->error = true;
     986                nwritten = 0;
     987        }
     988
     989        return nwritten / size;
     990}
     991
     992/** Flush KIO stream. */
     993static int stdio_kio_flush(FILE *stream)
     994{
     995        kio_update();
     996        return 0;
     997}
     998
     999/** Read from VFS stream. */
     1000static size_t stdio_vfs_read(void *buf, size_t size, size_t nmemb, FILE *stream)
     1001{
     1002        errno_t rc;
     1003        size_t nread;
     1004
     1005        if (size == 0 || nmemb == 0)
     1006                return 0;
     1007
     1008        rc = vfs_read(stream->fd, &stream->pos, buf, size * nmemb, &nread);
     1009        if (rc != EOK) {
     1010                errno = rc;
     1011                stream->error = true;
     1012        } else if (nread == 0) {
     1013                stream->eof = true;
     1014        }
     1015
     1016        return (nread / size);
     1017}
     1018
     1019/** Write to VFS stream. */
     1020static size_t stdio_vfs_write(const void *buf, size_t size, size_t nmemb,
     1021    FILE *stream)
     1022{
     1023        errno_t rc;
     1024        size_t nwritten;
     1025
     1026        rc = vfs_write(stream->fd, &stream->pos, buf, size * nmemb, &nwritten);
     1027        if (rc != EOK) {
     1028                errno = rc;
     1029                stream->error = true;
     1030        }
     1031
     1032        return nwritten / size;
     1033}
     1034
     1035/** Flush VFS stream. */
     1036static int stdio_vfs_flush(FILE *stream)
     1037{
     1038        errno_t rc;
     1039
     1040        rc = vfs_sync(stream->fd);
     1041        if (rc != EOK) {
     1042                errno = rc;
     1043                return EOF;
     1044        }
     1045
     1046        return 0;
     1047}
     1048
    9801049/** @}
    9811050 */
Note: See TracChangeset for help on using the changeset viewer.