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


Ignore:
Timestamp:
2017-03-24T20:31:54Z (8 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

Location:
uspace/lib/c/generic
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/elf/elf_mod.c

    rc9e3692 r58898d1d  
    135135        elf_header_t header_buf;
    136136        elf_header_t *header = &header_buf;
     137        aoff64_t pos = 0;
    137138        int i, rc;
    138139
    139         rc = read(elf->fd, header, sizeof(elf_header_t));
     140        rc = read(elf->fd, &pos, header, sizeof(elf_header_t));
    140141        if (rc != sizeof(elf_header_t)) {
    141142                DPRINTF("Read error.\n");
    … …  
    195196                elf_segment_header_t segment_hdr;
    196197
    197                 /* Seek to start of segment header */
    198                 lseek(elf->fd, header->e_phoff
    199                         + i * sizeof(elf_segment_header_t), SEEK_SET);
    200 
    201                 rc = read(elf->fd, &segment_hdr,
     198                pos = header->e_phoff + i * sizeof(elf_segment_header_t);
     199                rc = read(elf->fd, &pos, &segment_hdr,
    202200                    sizeof(elf_segment_header_t));
    203201                if (rc != sizeof(elf_segment_header_t)) {
    … …  
    217215                elf_section_header_t section_hdr;
    218216
    219                 /* Seek to start of section header */
    220                 lseek(elf->fd, header->e_shoff
    221                     + i * sizeof(elf_section_header_t), SEEK_SET);
    222 
    223                 rc = read(elf->fd, &section_hdr,
     217                pos = header->e_shoff + i * sizeof(elf_section_header_t);
     218                rc = read(elf->fd, &pos, &section_hdr,
    224219                    sizeof(elf_section_header_t));
    225220                if (rc != sizeof(elf_section_header_t)) {
    … …  
    333328        uintptr_t seg_addr;
    334329        size_t mem_sz;
     330        aoff64_t pos;
    335331        ssize_t rc;
    336332
    … …  
    390386         * Load segment data
    391387         */
    392         rc = lseek(elf->fd, entry->p_offset, SEEK_SET);
    393         if (rc < 0) {
    394                 printf("seek error\n");
    395                 return EE_INVALID;
    396         }
    397 
    398         rc = read(elf->fd, seg_ptr, entry->p_filesz);
     388        pos = entry->p_offset;
     389        rc = read(elf->fd, &pos, seg_ptr, entry->p_filesz);
    399390        if (rc < 0) {
    400391                DPRINTF("read error\n");

  • 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

  • uspace/lib/c/generic/private/stdio.h

    rc9e3692 r58898d1d  
    4949        /** Underlying file descriptor. */
    5050        int fd;
     51
     52        /** File position. */
     53        aoff64_t pos;
    5154       
    5255        /** Error indicator. */

  • uspace/lib/c/generic/vfs/vfs.c

    rc9e3692 r58898d1d  
    444444 *
    445445 * @param fildes File descriptor
     446 * @param pos Position to read from
    446447 * @param buf Buffer
    447448 * @param nbyte Maximum number of bytes to read
    … …  
    450451 * @return EOK on success, non-zero error code on error.
    451452 */
    452 static int _read_short(int fildes, void *buf, size_t nbyte, ssize_t *nread)
     453static int _read_short(int fildes, aoff64_t pos, void *buf, size_t nbyte,
     454    ssize_t *nread)
    453455{
    454456        sysarg_t rc;
    … …  
    461463        async_exch_t *exch = vfs_exchange_begin();
    462464       
    463         req = async_send_1(exch, VFS_IN_READ, fildes, &answer);
     465        req = async_send_3(exch, VFS_IN_READ, fildes, LOWER32(pos),
     466            UPPER32(pos), &answer);
    464467        rc = async_data_read_start(exch, (void *) buf, nbyte);
    465468
    … …  
    484487 *
    485488 * @param fildes File descriptor
     489 * @param pos Position to write to
    486490 * @param buf Buffer
    487491 * @param nbyte Maximum number of bytes to write
    … …  
    490494 * @return EOK on success, non-zero error code on error.
    491495 */
    492 static int _write_short(int fildes, const void *buf, size_t nbyte,
     496static int _write_short(int fildes, aoff64_t pos, const void *buf, size_t nbyte,
    493497    ssize_t *nwritten)
    494498{
    … …  
    502506        async_exch_t *exch = vfs_exchange_begin();
    503507       
    504         req = async_send_1(exch, VFS_IN_WRITE, fildes, &answer);
     508        req = async_send_3(exch, VFS_IN_WRITE, fildes, LOWER32(pos),
     509            UPPER32(pos), &answer);
    505510        rc = async_data_write_start(exch, (void *) buf, nbyte);
    506511       
    … …  
    525530 *
    526531 * @param fildes        File descriptor
     532 * @param pos           Pointer to position to read from
    527533 * @param buf           Buffer, @a nbytes bytes long
    528534 * @param nbytes        Number of bytes to read
    … …  
    531537 *                      On failure, -1 and sets errno.
    532538 */
    533 ssize_t read(int fildes, void *buf, size_t nbyte)
     539ssize_t read(int fildes, aoff64_t *pos, void *buf, size_t nbyte)
    534540{
    535541        ssize_t cnt = 0;
    … …  
    541547                bp += cnt;
    542548                nread += cnt;
    543                 rc = _read_short(fildes, bp, nbyte - nread, &cnt);
     549                *pos += cnt;
     550                rc = _read_short(fildes, *pos, bp, nbyte - nread, &cnt);
    544551        } while (rc == EOK && cnt > 0 && (nbyte - nread - cnt) > 0);
    545552       
    … …  
    549556        }
    550557       
     558        *pos += cnt;
    551559        return nread + cnt;
    552560}
    … …  
    557565 *
    558566 * @param fildes        File descriptor
     567 * @param pos           Pointer to position to write to
    559568 * @param buf           Data, @a nbytes bytes long
    560569 * @param nbytes        Number of bytes to write
    … …  
    563572 *                      On failure, -1 and sets errno.
    564573 */
    565 ssize_t write(int fildes, const void *buf, size_t nbyte)
     574ssize_t write(int fildes, aoff64_t *pos, const void *buf, size_t nbyte)
    566575{
    567576        ssize_t cnt = 0;
    … …  
    573582                bp += cnt;
    574583                nwritten += cnt;
    575                 rc = _write_short(fildes, bp, nbyte - nwritten, &cnt);
     584                *pos += cnt;
     585                rc = _write_short(fildes, *pos, bp, nbyte - nwritten, &cnt);
    576586        } while (rc == EOK && ((ssize_t )nbyte - nwritten - cnt) > 0);
    577587
    … …  
    581591        }
    582592
     593        *pos += cnt;
    583594        return nbyte;
    584595}
    … …  
    601612       
    602613        return 0;
    603 }
    604 
    605 /** Seek to a position.
    606  *
    607  * @param fildes File descriptor
    608  * @param offset Offset
    609  * @param whence SEEK_SET, SEEK_CUR or SEEK_END
    610  *
    611  * @return On success the nonnegative offset from start of file. On error
    612  *         returns (off64_t)-1 and sets errno.
    613  */
    614 off64_t lseek(int fildes, off64_t offset, int whence)
    615 {
    616         async_exch_t *exch = vfs_exchange_begin();
    617        
    618         sysarg_t newoff_lo;
    619         sysarg_t newoff_hi;
    620         sysarg_t rc = async_req_4_2(exch, VFS_IN_SEEK, fildes,
    621             LOWER32(offset), UPPER32(offset), whence,
    622             &newoff_lo, &newoff_hi);
    623        
    624         vfs_exchange_end(exch);
    625        
    626         if (rc != EOK) {
    627                 errno = rc;
    628                 return (off64_t) -1;
    629         }
    630        
    631         return (off64_t) MERGE_LOUP32(newoff_lo, newoff_hi);
    632614}
    633615
    … …  
    757739       
    758740        dirp->fd = fd;
     741        dirp->pos = 0;
    759742        return dirp;
    760743}
    … …  
    771754        ssize_t len;
    772755       
    773         rc = _read_short(dirp->fd, &dirp->res.d_name[0], NAME_MAX + 1, &len);
     756        rc = _read_short(dirp->fd, dirp->pos, &dirp->res.d_name[0],
     757            NAME_MAX + 1, &len);
    774758        if (rc != EOK) {
    775759                errno = rc;
    … …  
    777761        }
    778762       
    779         (void) len;
     763        dirp->pos += len;
     764       
    780765        return &dirp->res;
    781766}
    … …  
    787772void rewinddir(DIR *dirp)
    788773{
    789         (void) lseek(dirp->fd, 0, SEEK_SET);
     774        dirp->pos = 0;
    790775}
    791776
Note: See TracChangeset for help on using the changeset viewer.