tools/testing/selftests/kvm/lib/io.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * tools/testing/selftests/kvm/lib/io.c
   4  *
   5  * Copyright (C) 2018, Google LLC.
   6  */
   7
   8 #include "test_util.h"
   9
  10 /* Test Write
  11  *
  12  * A wrapper for write(2), that automatically handles the following
  13  * special conditions:
  14  *
  15  *   + Interrupted system call (EINTR)
  16  *   + Write of less than requested amount
  17  *   + Non-block return (EAGAIN)
  18  *
  19  * For each of the above, an additional write is performed to automatically
  20  * continue writing the requested data.
  21  * There are also many cases where write(2) can return an unexpected
  22  * error (e.g. EIO).  Such errors cause a TEST_ASSERT failure.
  23  *
  24  * Note, for function signature compatibility with write(2), this function
  25  * returns the number of bytes written, but that value will always be equal
  26  * to the number of requested bytes.  All other conditions in this and
  27  * future enhancements to this function either automatically issue another
  28  * write(2) or cause a TEST_ASSERT failure.
  29  *
  30  * Args:
  31  *  fd    - Opened file descriptor to file to be written.
  32  *  count - Number of bytes to write.
  33  *
  34  * Output:
  35  *  buf   - Starting address of data to be written.
  36  *
  37  * Return:
  38  *  On success, number of bytes written.
  39  *  On failure, a TEST_ASSERT failure is caused.
  40  */
  41 ssize_t test_write(int fd, const void *buf, size_t count)
  42 {
  43         ssize_t rc;
  44         ssize_t num_written = 0;
  45         size_t num_left = count;
  46         const char *ptr = buf;
  47
  48         /* Note: Count of zero is allowed (see "RETURN VALUE" portion of
  49          * write(2) manpage for details.
  50          */
  51         TEST_ASSERT(count >= 0, "Unexpected count, count: %li", count);
  52
  53         do {
  54                 rc = write(fd, ptr, num_left);
  55
  56                 switch (rc) {
  57                 case -1:
  58                         TEST_ASSERT(errno == EAGAIN || errno == EINTR,
  59                                     "Unexpected write failure,\n"
  60                                     "  rc: %zi errno: %i", rc, errno);
  61                         continue;
  62
  63                 case 0:
  64                         TEST_FAIL("Unexpected EOF,\n"
  65                                   "  rc: %zi num_written: %zi num_left: %zu",
  66                                   rc, num_written, num_left);
  67                         break;
  68
  69                 default:
  70                         TEST_ASSERT(rc >= 0, "Unexpected ret from write,\n"
  71                                 "  rc: %zi errno: %i", rc, errno);
  72                         num_written += rc;
  73                         num_left -= rc;
  74                         ptr += rc;
  75                         break;
  76                 }
  77         } while (num_written < count);
  78
  79         return num_written;
  80 }
  81
  82 /* Test Read
  83  *
  84  * A wrapper for read(2), that automatically handles the following
  85  * special conditions:
  86  *
  87  *   + Interrupted system call (EINTR)
  88  *   + Read of less than requested amount
  89  *   + Non-block return (EAGAIN)
  90  *
  91  * For each of the above, an additional read is performed to automatically
  92  * continue reading the requested data.
  93  * There are also many cases where read(2) can return an unexpected
  94  * error (e.g. EIO).  Such errors cause a TEST_ASSERT failure.  Note,
  95  * it is expected that the file opened by fd at the current file position
  96  * contains at least the number of requested bytes to be read.  A TEST_ASSERT
  97  * failure is produced if an End-Of-File condition occurs, before all the
  98  * data is read.  It is the callers responsibility to assure that sufficient
  99  * data exists.
 100  *
 101  * Note, for function signature compatibility with read(2), this function
 102  * returns the number of bytes read, but that value will always be equal
 103  * to the number of requested bytes.  All other conditions in this and
 104  * future enhancements to this function either automatically issue another
 105  * read(2) or cause a TEST_ASSERT failure.
 106  *
 107  * Args:
 108  *  fd    - Opened file descriptor to file to be read.
 109  *  count - Number of bytes to read.
 110  *
 111  * Output:
 112  *  buf   - Starting address of where to write the bytes read.
 113  *
 114  * Return:
 115  *  On success, number of bytes read.
 116  *  On failure, a TEST_ASSERT failure is caused.
 117  */
 118 ssize_t test_read(int fd, void *buf, size_t count)
 119 {
 120         ssize_t rc;
 121         ssize_t num_read = 0;
 122         size_t num_left = count;
 123         char *ptr = buf;
 124
 125         /* Note: Count of zero is allowed (see "If count is zero" portion of
 126          * read(2) manpage for details.
 127          */
 128         TEST_ASSERT(count >= 0, "Unexpected count, count: %li", count);
 129
 130         do {
 131                 rc = read(fd, ptr, num_left);
 132
 133                 switch (rc) {
 134                 case -1:
 135                         TEST_ASSERT(errno == EAGAIN || errno == EINTR,
 136                                     "Unexpected read failure,\n"
 137                                     "  rc: %zi errno: %i", rc, errno);
 138                         break;
 139
 140                 case 0:
 141                         TEST_FAIL("Unexpected EOF,\n"
 142                                   "   rc: %zi num_read: %zi num_left: %zu",
 143                                   rc, num_read, num_left);
 144                         break;
 145
 146                 default:
 147                         TEST_ASSERT(rc > 0, "Unexpected ret from read,\n"
 148                                     "  rc: %zi errno: %i", rc, errno);
 149                         num_read += rc;
 150                         num_left -= rc;
 151                         ptr += rc;
 152                         break;
 153                 }
 154         } while (num_read < count);
 155
 156         return num_read;
 157 }