Changeset 8e3498b in mainline for uspace/lib/c


Ignore:
Timestamp:
2017-12-04T18:44:24Z (8 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
bde5c04
Parents:
40feeac
Message:

vfs_read/write() should return error code separately from number of bytes transferred.

Location:
uspace/lib/c
Files:
4 edited

Legend:

Unmodified
Added
Removed

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

    r40feeac r8e3498b  
    137137        elf_header_t *header = &header_buf;
    138138        aoff64_t pos = 0;
     139        size_t nr;
    139140        int i, rc;
    140141
    141         rc = vfs_read(elf->fd, &pos, header, sizeof(elf_header_t));
    142         if (rc != sizeof(elf_header_t)) {
     142        rc = vfs_read(elf->fd, &pos, header, sizeof(elf_header_t), &nr);
     143        if (rc != EOK || nr != sizeof(elf_header_t)) {
    143144                DPRINTF("Read error.\n");
    144145                return EE_INVALID;
    … …  
    199200                pos = header->e_phoff + i * sizeof(elf_segment_header_t);
    200201                rc = vfs_read(elf->fd, &pos, &segment_hdr,
    201                     sizeof(elf_segment_header_t));
    202                 if (rc != sizeof(elf_segment_header_t)) {
     202                    sizeof(elf_segment_header_t), &nr);
     203                if (rc != EOK || nr != sizeof(elf_segment_header_t)) {
    203204                        DPRINTF("Read error.\n");
    204205                        return EE_INVALID;
    … …  
    218219                pos = header->e_shoff + i * sizeof(elf_section_header_t);
    219220                rc = vfs_read(elf->fd, &pos, &section_hdr,
    220                     sizeof(elf_section_header_t));
    221                 if (rc != sizeof(elf_section_header_t)) {
     221                    sizeof(elf_section_header_t), &nr);
     222                if (rc != EOK || nr != sizeof(elf_section_header_t)) {
    222223                        DPRINTF("Read error.\n");
    223224                        return EE_INVALID;
    … …  
    330331        size_t mem_sz;
    331332        aoff64_t pos;
    332         ssize_t rc;
     333        int rc;
     334        size_t nr;
    333335
    334336        bias = elf->bias;
    … …  
    388390         */
    389391        pos = entry->p_offset;
    390         rc = vfs_read(elf->fd, &pos, seg_ptr, entry->p_filesz);
    391         if (rc < 0) {
     392        rc = vfs_read(elf->fd, &pos, seg_ptr, entry->p_filesz, &nr);
     393        if (rc != EOK || nr != entry->p_filesz) {
    392394                DPRINTF("read error\n");
    393395                return EE_INVALID;

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

    r40feeac r8e3498b  
    430430static size_t _fread(void *buf, size_t size, size_t nmemb, FILE *stream)
    431431{
     432        int rc;
     433        size_t nread;
     434
    432435        if (size == 0 || nmemb == 0)
    433436                return 0;
    434437
    435         ssize_t rd = vfs_read(stream->fd, &stream->pos, buf, size * nmemb);
    436         if (rd < 0) {
    437                 errno = rd;
     438        rc = vfs_read(stream->fd, &stream->pos, buf, size * nmemb, &nread);
     439        if (rc != EOK) {
     440                errno = rc;
    438441                stream->error = true;
    439                 rd = 0;
    440         } else if (rd == 0) {
     442        } else if (nread == 0) {
    441443                stream->eof = true;
    442444        }
    443        
    444         return (rd / size);
     445
     446        return (nread / size);
    445447}
    446448
    … …  
    457459static size_t _fwrite(const void *buf, size_t size, size_t nmemb, FILE *stream)
    458460{
     461        int rc;
     462        size_t nwritten;
     463
    459464        if (size == 0 || nmemb == 0)
    460465                return 0;
    461466
    462         ssize_t wr;
    463467        if (stream->kio) {
    464                 size_t nwritten;
    465                 wr = kio_write(buf, size * nmemb, &nwritten);
    466                 if (wr != EOK) {
     468                rc = kio_write(buf, size * nmemb, &nwritten);
     469                if (rc != EOK) {
    467470                        stream->error = true;
    468                         wr = 0;
    469                 } else {
    470                         wr = nwritten;
     471                        nwritten = 0;
    471472                }
    472473        } else {
    473                 wr = vfs_write(stream->fd, &stream->pos, buf, size * nmemb);
    474                 if (wr < 0) {
    475                         errno = wr;
     474                rc = vfs_write(stream->fd, &stream->pos, buf, size * nmemb,
     475                    &nwritten);
     476                if (rc != EOK) {
     477                        errno = rc;
    476478                        stream->error = true;
    477                         wr = 0;
    478479                }
    479480        }
    480481
    481         if (wr > 0)
     482        if (nwritten > 0)
    482483                stream->need_sync = true;
    483        
    484         return (wr / size);
     484
     485        return (nwritten / size);
    485486}
    486487
    … …  
    491492static void _ffillbuf(FILE *stream)
    492493{
    493         ssize_t rc;
     494        int rc;
     495        size_t nread;
    494496
    495497        stream->buf_head = stream->buf_tail = stream->buf;
    496498
    497         rc = vfs_read(stream->fd, &stream->pos, stream->buf, stream->buf_size);
    498         if (rc < 0) {
     499        rc = vfs_read(stream->fd, &stream->pos, stream->buf, stream->buf_size,
     500            &nread);
     501        if (rc != EOK) {
    499502                errno = rc;
    500503                stream->error = true;
    … …  
    502505        }
    503506
    504         if (rc == 0) {
     507        if (nread == 0) {
    505508                stream->eof = true;
    506509                return;
    507510        }
    508511
    509         stream->buf_head += rc;
     512        stream->buf_head += nread;
    510513        stream->buf_state = _bs_read;
    511514}

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

    r40feeac r8e3498b  
    8686 * and consume system resources.
    8787 *
    88  * Functions that return int return a negative error code on error and do not
     88 * Functions that return int return an error code on error and do not
    8989 * set errno. Depending on function, success is signalled by returning either
    9090 * EOK or a non-negative file handle.
    … …  
    104104 *      aoff64_t pos = 42;
    105105 *      char buf[512];
    106  *      ssize_t size = vfs_read(file, &pos, buf, sizeof(buf));
    107  *      if (size < 0) {
     106 *      size_t nread;
     107 *      rc = vfs_read(file, &pos, buf, sizeof(buf), &nread);
     108 *      if (rc != EOK) {
    108109 *              vfs_put(file);
    109  *              return size;
     110 *              return rc;
    110111 *      }
    111112 *
    112  *      // buf is now filled with data from file
     113 *      // buf is now filled with nread bytes from file
    113114 *
    114115 *      vfs_put(file);
    … …  
    808809 * @param buf           Buffer, @a nbytes bytes long
    809810 * @param nbytes        Number of bytes to read
    810  *
    811  * @return              On success, non-negative number of bytes read
    812  * @return              On failure, a negative error code
    813  */
    814 ssize_t vfs_read(int file, aoff64_t *pos, void *buf, size_t nbyte)
     811 * @param nread         Place to store number of bytes actually read
     812 *
     813 * @return              On success, EOK and @a *nread is filled with number
     814 *                      of bytes actually read.
     815 * @return              On failure, an error code
     816 */
     817int vfs_read(int file, aoff64_t *pos, void *buf, size_t nbyte, size_t *nread)
    815818{
    816819        ssize_t cnt = 0;
    817         size_t nread = 0;
     820        size_t nr = 0;
    818821        uint8_t *bp = (uint8_t *) buf;
    819822        int rc;
    … …  
    821824        do {
    822825                bp += cnt;
    823                 nread += cnt;
     826                nr += cnt;
    824827                *pos += cnt;
    825                 rc = vfs_read_short(file, *pos, bp, nbyte - nread, &cnt);
    826         } while (rc == EOK && cnt > 0 && (nbyte - nread - cnt) > 0);
    827        
    828         if (rc != EOK)
     828                rc = vfs_read_short(file, *pos, bp, nbyte - nr, &cnt);
     829        } while (rc == EOK && cnt > 0 && (nbyte - nr - cnt) > 0);
     830       
     831        if (rc != EOK) {
     832                *nread = nr;
    829833                return rc;
    830        
     834        }
     835       
     836        nr += cnt;
    831837        *pos += cnt;
    832         return nread + cnt;
     838        *nread = nr;
     839        return EOK;
    833840}
    834841
    … …  
    12471254 * @param buf           Data, @a nbytes bytes long
    12481255 * @param nbytes        Number of bytes to write
    1249  *
    1250  * @return              On success, non-negative number of bytes written
    1251  * @return              On failure, a negative error code
    1252  */
    1253 ssize_t vfs_write(int file, aoff64_t *pos, const void *buf, size_t nbyte)
     1256 * @param nwritten      Place to store number of bytes written
     1257 *
     1258 * @return              On success, EOK, @a *nwr is filled with number
     1259 *                      of bytes written
     1260 * @return              On failure, an error code
     1261 */
     1262int vfs_write(int file, aoff64_t *pos, const void *buf, size_t nbyte,
     1263    size_t *nwritten)
    12541264{
    12551265        ssize_t cnt = 0;
    1256         ssize_t nwritten = 0;
     1266        ssize_t nwr = 0;
    12571267        const uint8_t *bp = (uint8_t *) buf;
    12581268        int rc;
    … …  
    12601270        do {
    12611271                bp += cnt;
    1262                 nwritten += cnt;
     1272                nwr += cnt;
    12631273                *pos += cnt;
    1264                 rc = vfs_write_short(file, *pos, bp, nbyte - nwritten, &cnt);
    1265         } while (rc == EOK && ((ssize_t )nbyte - nwritten - cnt) > 0);
    1266 
    1267         if (rc != EOK)
     1274                rc = vfs_write_short(file, *pos, bp, nbyte - nwr, &cnt);
     1275        } while (rc == EOK && ((ssize_t )nbyte - nwr - cnt) > 0);
     1276
     1277        if (rc != EOK) {
     1278                *nwritten = nwr;
    12681279                return rc;
    1269 
     1280        }
     1281
     1282        nwr += cnt;
    12701283        *pos += cnt;
    1271         return nbyte;
     1284        *nwritten = nwr;
     1285        return EOK;
    12721286}
    12731287

  • uspace/lib/c/include/vfs/vfs.h

    r40feeac r8e3498b  
    104104extern int vfs_pass_handle(async_exch_t *, int, async_exch_t *);
    105105extern int vfs_put(int);
    106 extern ssize_t vfs_read(int, aoff64_t *, void *, size_t);
     106extern int vfs_read(int, aoff64_t *, void *, size_t, size_t *);
    107107extern int vfs_read_short(int, aoff64_t, void *, size_t, ssize_t *);
    108108extern int vfs_receive_handle(bool);
    … …  
    121121extern int vfs_unmount_path(const char *);
    122122extern int vfs_walk(int, const char *, int);
    123 extern ssize_t vfs_write(int, aoff64_t *, const void *, size_t);
     123extern int vfs_write(int, aoff64_t *, const void *, size_t, size_t *);
    124124extern int vfs_write_short(int, aoff64_t, const void *, size_t, ssize_t *);
    125125
Note: See TracChangeset for help on using the changeset viewer.