Changeset 58898d1d in mainline for uspace/lib/c/generic/io/io.c


Ignore:
Timestamp:
2017-03-24T20:31:54Z (7 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
8e9b2534
Parents:
c9e3692
Message:

Remove VFS_IN_SEEK from VFS

File:
1 edited

Legend:

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

    rc9e3692 r58898d1d  
    4141#include <stdbool.h>
    4242#include <malloc.h>
     43#include <sys/stat.h>
    4344#include <async.h>
    4445#include <io/kio.h>
     
    5657static FILE stdin_null = {
    5758        .fd = -1,
     59        .pos = 0,
    5860        .error = true,
    5961        .eof = true,
     
    7072static FILE stdout_kio = {
    7173        .fd = -1,
     74        .pos = 0,
    7275        .error = false,
    7376        .eof = false,
     
    8487static FILE stderr_kio = {
    8588        .fd = -1,
     89        .pos = 0,
    8690        .error = false,
    8791        .eof = false,
     
    288292        }
    289293       
     294        stream->pos = 0;
    290295        stream->error = false;
    291296        stream->eof = false;
     
    311316       
    312317        stream->fd = fd;
     318        stream->pos = 0;
    313319        stream->error = false;
    314320        stream->eof = false;
     
    396402static size_t _fread(void *buf, size_t size, size_t nmemb, FILE *stream)
    397403{
    398         size_t left, done;
    399 
    400404        if (size == 0 || nmemb == 0)
    401405                return 0;
    402406
    403         left = size * nmemb;
    404         done = 0;
    405        
    406         while ((left > 0) && (!stream->error) && (!stream->eof)) {
    407                 ssize_t rd = read(stream->fd, buf + done, left);
    408                
    409                 if (rd < 0) {
    410                         /* errno was set by read() */
    411                         stream->error = true;
    412                 } else if (rd == 0) {
    413                         stream->eof = true;
    414                 } else {
    415                         left -= rd;
    416                         done += rd;
    417                 }
    418         }
    419        
    420         return (done / size);
     407        ssize_t rd = read(stream->fd, &stream->pos, buf, size * nmemb);
     408        if (rd < 0) {
     409                /* errno was set by read() */
     410                stream->error = true;
     411                rd = 0;
     412        } else if (rd == 0) {
     413                stream->eof = true;
     414        }
     415       
     416        return (rd / size);
    421417}
    422418
     
    433429static size_t _fwrite(const void *buf, size_t size, size_t nmemb, FILE *stream)
    434430{
    435         size_t left;
    436         size_t done;
    437         int rc;
    438 
    439431        if (size == 0 || nmemb == 0)
    440432                return 0;
    441433
    442         left = size * nmemb;
    443         done = 0;
    444 
    445         while ((left > 0) && (!stream->error)) {
    446                 ssize_t wr;
    447                 size_t uwr;
    448                
    449                 if (stream->kio) {
    450                         uwr = 0;
    451                         rc = kio_write(buf + done, left, &uwr);
    452                         if (rc != EOK)
    453                                 errno = rc;
     434        ssize_t wr;
     435        if (stream->kio) {
     436                size_t nwritten;
     437                wr = kio_write(buf, size * nmemb, &nwritten);
     438                if (wr != EOK) {
     439                        stream->error = true;
     440                        wr = 0;
    454441                } else {
    455                         wr = write(stream->fd, buf + done, left);
    456                         if (wr >= 0) {
    457                                 uwr = (size_t)wr;
    458                                 rc = EOK;
    459                         } else {
    460                                 /* errno was set by write */
    461                                 uwr = 0;
    462                                 rc = errno;
    463                         }
    464                 }
    465                
    466                 if (rc != EOK) {
    467                         /* errno was set above */
     442                        wr = nwritten;
     443                }
     444        } else {
     445                wr = write(stream->fd, &stream->pos, buf, size * nmemb);
     446                if (wr < 0) {
     447                        /* errno was set by write() */
    468448                        stream->error = true;
    469                 } else {
    470                         left -= uwr;
    471                         done += uwr;
    472                 }
    473         }
    474 
    475         if (done > 0)
     449                        wr = 0;
     450                }
     451        }
     452
     453        if (wr > 0)
    476454                stream->need_sync = true;
    477455       
    478         return (done / size);
     456        return (wr / size);
    479457}
    480458
     
    489467        stream->buf_head = stream->buf_tail = stream->buf;
    490468
    491         rc = read(stream->fd, stream->buf, stream->buf_size);
     469        rc = read(stream->fd, &stream->pos, stream->buf, stream->buf_size);
    492470        if (rc < 0) {
    493471                /* errno was set by read() */
     
    516494
    517495        /* If buffer has prefetched read data, we need to seek back. */
    518         if (bytes_used > 0 && stream->buf_state == _bs_read) {
    519                 off64_t rc;
    520                 rc = lseek(stream->fd, - (ssize_t) bytes_used, SEEK_CUR);
    521                 if (rc == (off64_t)-1) {
    522                         /* errno was set by lseek */
    523                         stream->error = 1;
    524                         return;
    525                 }
    526         }
     496        if (bytes_used > 0 && stream->buf_state == _bs_read)
     497                stream->pos -= bytes_used;
    527498
    528499        /* If buffer has unwritten data, we need to write them out. */
     
    796767int fseek(FILE *stream, off64_t offset, int whence)
    797768{
    798         off64_t rc;
    799 
    800769        if (stream->error)
    801                 return EOF;
     770                return -1;
    802771
    803772        _fflushbuf(stream);
    804773        if (stream->error) {
    805774                /* errno was set by _fflushbuf() */
    806                 return EOF;
     775                return -1;
    807776        }
    808777
    809778        stream->ungetc_chars = 0;
    810779
    811         rc = lseek(stream->fd, offset, whence);
    812         if (rc == (off64_t) (-1)) {
    813                 /* errno has been set by lseek() */
    814                 return EOF;
     780        struct stat st;
     781        switch (whence) {
     782        case SEEK_SET:
     783                stream->pos = offset;
     784                break;
     785        case SEEK_CUR:
     786                stream->pos += offset;
     787                break;
     788        case SEEK_END:
     789                if (fstat(stream->fd, &st) != EOK) {
     790                        /* errno was set by fstat() */
     791                        stream->error = true;
     792                        return -1;     
     793                }
     794                stream->pos = st.size + offset;
     795                break;
    815796        }
    816797
     
    821802off64_t ftell(FILE *stream)
    822803{
    823         off64_t pos;
    824        
    825804        if (stream->error)
    826805                return EOF;
     
    832811        }
    833812
    834         pos = lseek(stream->fd, 0, SEEK_CUR);
    835         if (pos == (off64_t) -1) {
    836                 /* errno was set by lseek */
    837                 return (off64_t) -1;
    838         }
    839        
    840         return pos - stream->ungetc_chars;
     813        return stream->pos - stream->ungetc_chars;
    841814}
    842815
Note: See TracChangeset for help on using the changeset viewer.