|
| 1 | +// CR-150: isolate pipe flag observations from every engine operation. |
| 2 | +#include "fd_flag_diagnostics.hpp" |
| 3 | + |
| 4 | +#include <array> |
| 5 | +#include <cerrno> |
| 6 | +#include <cstdio> |
| 7 | +#include <stdexcept> |
| 8 | +#include <string> |
| 9 | + |
| 10 | +#include <fcntl.h> |
| 11 | +#include <unistd.h> |
| 12 | + |
| 13 | +namespace { |
| 14 | +void require(bool condition, const std::string& message) { |
| 15 | + if (!condition) throw std::runtime_error(message); |
| 16 | +} |
| 17 | + |
| 18 | +struct Pipe { |
| 19 | + int descriptors[2]{-1, -1}; |
| 20 | + Pipe() { |
| 21 | + require(::pipe(descriptors) == 0, "pipe failed"); |
| 22 | + // Exactly the reader setup used by both nonfinite-equity fd tests. |
| 23 | + const int flags = ::fcntl(descriptors[0], F_GETFL); |
| 24 | + require(flags >= 0 && ::fcntl(descriptors[0], F_SETFL, flags | O_NONBLOCK) == 0, |
| 25 | + "nonblocking reader setup failed"); |
| 26 | + } |
| 27 | + ~Pipe() { |
| 28 | + for (const int fd : descriptors) if (fd >= 0) ::close(fd); |
| 29 | + } |
| 30 | + std::string drain() const { |
| 31 | + std::string bytes; |
| 32 | + std::array<char, 4096> buffer{}; |
| 33 | + for (;;) { |
| 34 | + const auto count = ::read(descriptors[0], buffer.data(), buffer.size()); |
| 35 | + if (count < 0 && errno == EINTR) continue; |
| 36 | + if (count < 0 && (errno == EAGAIN || errno == EWOULDBLOCK)) return bytes; |
| 37 | + require(count >= 0, "pipe read failed"); |
| 38 | + if (count == 0) return bytes; |
| 39 | + bytes.append(buffer.data(), static_cast<std::size_t>(count)); |
| 40 | + } |
| 41 | + } |
| 42 | + void duplicate_writer() { |
| 43 | + // Match L22A's inherited descriptor allocation and original close. |
| 44 | + const int duplicate = ::fcntl(descriptors[1], F_DUPFD_CLOEXEC, 17); |
| 45 | + require(duplicate >= 17, "cannot allocate a non-default inherited fd"); |
| 46 | + const int original = descriptors[1]; |
| 47 | + descriptors[1] = duplicate; |
| 48 | + require(::close(original) == 0, "original writer close failed"); |
| 49 | + } |
| 50 | + void close_reader() { |
| 51 | + const int reader = descriptors[0]; |
| 52 | + descriptors[0] = -1; |
| 53 | + require(::close(reader) == 0, "pipe reader close failed"); |
| 54 | + } |
| 55 | +}; |
| 56 | + |
| 57 | +void run_case(bool duplicate_writer) { |
| 58 | + Pipe pipe; |
| 59 | + if (duplicate_writer) pipe.duplicate_writer(); |
| 60 | + fd_flag_diagnostics::Trace fd_trace(pipe.descriptors[1], "before nonempty write"); |
| 61 | + const int flags = fd_trace.baseline().flags; |
| 62 | + const int descriptor_flags = fd_trace.baseline().descriptor_flags; |
| 63 | + require(flags >= 0 && descriptor_flags >= 0, fd_trace.message("cannot read pipe writer flags")); |
| 64 | + |
| 65 | + constexpr char payload[] = "borrowed-pipe-control"; |
| 66 | + ssize_t written; |
| 67 | + do { |
| 68 | + written = ::write(pipe.descriptors[1], payload, sizeof payload - 1); |
| 69 | + } while (written < 0 && errno == EINTR); |
| 70 | + require(written == static_cast<ssize_t>(sizeof payload - 1), "nonempty pipe write failed"); |
| 71 | + const auto after_write = fd_trace.record("after nonempty write"); |
| 72 | + const auto bytes = pipe.drain(); |
| 73 | + const auto after_drain = fd_trace.record("after draining reader"); |
| 74 | + require(bytes == payload, "pipe control drain changed payload"); |
| 75 | + pipe.close_reader(); |
| 76 | + const auto after_close = fd_trace.record("after closing reader"); |
| 77 | + |
| 78 | +#if defined(__APPLE__) |
| 79 | + const int raw_difference = flags ^ after_write.flags; |
| 80 | + require(raw_difference == 0 || raw_difference == fd_flag_diagnostics::darwin_was_written, |
| 81 | + fd_trace.message("pipe write changed more than Darwin's written bit")); |
| 82 | +#else |
| 83 | + require(after_write.flags == flags && after_drain.flags == flags && after_close.flags == flags, |
| 84 | + fd_trace.message("pipe write changed raw status flags")); |
| 85 | +#endif |
| 86 | + require(fd_flag_diagnostics::same_flags(fd_trace.baseline(), after_write) |
| 87 | + && fd_flag_diagnostics::same_flags(fd_trace.baseline(), after_drain) |
| 88 | + && fd_flag_diagnostics::same_flags(fd_trace.baseline(), after_close), |
| 89 | + fd_trace.message("comparable pipe writer flags changed")); |
| 90 | + require(fd_flag_diagnostics::comparable_status_flags(after_write.flags) |
| 91 | + == fd_flag_diagnostics::comparable_status_flags(flags) |
| 92 | + && after_write.descriptor_flags == descriptor_flags |
| 93 | + && fd_flag_diagnostics::comparable_status_flags(after_drain.flags) |
| 94 | + == fd_flag_diagnostics::comparable_status_flags(flags) |
| 95 | + && after_drain.descriptor_flags == descriptor_flags |
| 96 | + && fd_flag_diagnostics::comparable_status_flags(after_close.flags) |
| 97 | + == fd_flag_diagnostics::comparable_status_flags(flags) |
| 98 | + && after_close.descriptor_flags == descriptor_flags, |
| 99 | + fd_trace.message("pipe writer flags changed")); |
| 100 | + |
| 101 | + // Mutate observations of the real pipe without involving an engine. |
| 102 | + for (const int bit : {O_NONBLOCK, O_APPEND, O_ACCMODE}) { |
| 103 | + auto changed = fd_trace.baseline(); |
| 104 | + changed.flags ^= bit; |
| 105 | + require(fd_flag_diagnostics::comparable_status_flags(changed.flags) |
| 106 | + != fd_flag_diagnostics::comparable_status_flags(flags) |
| 107 | + && !fd_flag_diagnostics::same_flags(fd_trace.baseline(), changed), |
| 108 | + fd_trace.message("comparison hid a caller-controlled status flag change")); |
| 109 | + } |
| 110 | + auto changed_descriptor = fd_trace.baseline(); |
| 111 | + changed_descriptor.descriptor_flags ^= FD_CLOEXEC; |
| 112 | + require(!fd_flag_diagnostics::same_flags(fd_trace.baseline(), changed_descriptor), |
| 113 | + fd_trace.message("comparison hid an FD_CLOEXEC change")); |
| 114 | + auto failed_query = fd_trace.baseline(); |
| 115 | + failed_query.flags = -1; |
| 116 | + require(fd_flag_diagnostics::comparable_status_flags(failed_query.flags) == failed_query.flags |
| 117 | + && !fd_flag_diagnostics::same_flags(fd_trace.baseline(), failed_query) |
| 118 | + && !fd_flag_diagnostics::same_flags(failed_query, fd_trace.baseline()) |
| 119 | + && !fd_flag_diagnostics::same_flags(failed_query, failed_query), |
| 120 | + fd_trace.message("failed F_GETFL query compared equal")); |
| 121 | +} |
| 122 | +} // namespace |
| 123 | + |
| 124 | +int main() { |
| 125 | + const char* active_case = "plain writer"; |
| 126 | + try { |
| 127 | + run_case(false); |
| 128 | + active_case = "F_DUPFD_CLOEXEC writer"; |
| 129 | + run_case(true); |
| 130 | + return 0; |
| 131 | + } catch (const std::exception& error) { |
| 132 | + std::fprintf(stderr, "pipe writer fd control (%s): %s\n", active_case, error.what()); |
| 133 | + return 1; |
| 134 | + } |
| 135 | +} |
0 commit comments