cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

io.c (4450B)

      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 */
     41ssize_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 */
    118ssize_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}