Changeset 8e3498b in mainline for uspace/lib


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
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/bithenge/src/file.c

    r40feeac r8e3498b  
    7777                return ELIMIT;
    7878
    79         ssize_t amount_read = vfs_read(blob->fd, &offset, buffer, *size);
    80         if (amount_read < 0)
     79        size_t amount_read;
     80        int rc = vfs_read(blob->fd, &offset, buffer, *size, &amount_read);
     81        if (rc != EOK)
    8182                return errno;
    8283        *size += amount_read;

  • 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

  • uspace/lib/pcut/src/os/helenos.c

    r40feeac r8e3498b  
    213213
    214214        aoff64_t pos = 0;
    215         vfs_read(tempfile, &pos, extra_output_buffer, OUTPUT_BUFFER_SIZE);
     215        size_t nread;
     216        vfs_read(tempfile, &pos, extra_output_buffer, OUTPUT_BUFFER_SIZE, &nread);
    216217
    217218leave_close_tempfile:

  • uspace/lib/posix/source/stdio.c

    r40feeac r8e3498b  
    343343{
    344344        const int fildes = *(int *) fd;
    345         ssize_t wr = vfs_write(fildes, &posix_pos[fildes], str, size);
    346         if (wr < 0)
    347                 return wr;
     345        size_t wr;
     346        int rc = vfs_write(fildes, &posix_pos[fildes], str, size, &wr);
     347        if (rc != EOK)
     348                return rc;
    348349        return str_nlength(str, wr);
    349350}
    … …  
    371372               
    372373                const int fildes = *(int *) fd;
    373                 if (vfs_write(fildes, &posix_pos[fildes], buf, sz) < 0)
     374                size_t nwr;
     375                if (vfs_write(fildes, &posix_pos[fildes], buf, sz, &nwr) != EOK)
    374376                        break;
    375377               

  • uspace/lib/posix/source/unistd.c

    r40feeac r8e3498b  
    213213ssize_t posix_read(int fildes, void *buf, size_t nbyte)
    214214{
    215         ssize_t size = rcerrno(vfs_read, fildes, &posix_pos[fildes], buf, nbyte);
    216         if (size < 0)
    217                 return -1;
    218         return size;
     215        size_t nread;
     216        int rc;
     217
     218        rc = rcerrno(vfs_read, fildes, &posix_pos[fildes], buf, nbyte, &nread);
     219        if (rc != EOK)
     220                return -1;
     221        return (ssize_t) nread;
    219222}
    220223
    … …  
    229232ssize_t posix_write(int fildes, const void *buf, size_t nbyte)
    230233{
    231         ssize_t size = rcerrno(vfs_write, fildes, &posix_pos[fildes], buf, nbyte);
    232         if (size < 0)
    233                 return -1;
    234         return size;
     234        size_t nwr;
     235        int rc;
     236
     237        rc = rcerrno(vfs_write, fildes, &posix_pos[fildes], buf, nbyte, &nwr);
     238        if (rc != EOK)
     239                return -1;
     240        return nwr;
    235241}
    236242
Note: See TracChangeset for help on using the changeset viewer.