Add and use CheckedReadFD(), CheckedWriteFD(), and CheckedReadFDAtEOF()

util/mac/process_reader_test.cc

 // Copyright 2014 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 73 matching lines @@
 #else
     EXPECT_TRUE(process_reader.Is64Bit());
 #endif
 
     EXPECT_EQ(getpid(), process_reader.ParentProcessID());
     EXPECT_EQ(ChildPID(), process_reader.ProcessID());
 
     int read_fd = ReadPipeFD();
 
     mach_vm_address_t address;
-    ssize_t rv = ReadFD(read_fd, &address, sizeof(address));
-    ASSERT_EQ(static_cast<ssize_t>(sizeof(address)), rv)
-        << ErrnoMessage("read");
+    CheckedReadFD(read_fd, &address, sizeof(address));
 
     std::string read_string;
     ASSERT_TRUE(process_reader.Memory()->ReadCString(address, &read_string));
     EXPECT_EQ(kTestMemory, read_string);
-
-    // Tell the child that it’s OK to exit. The child needed to be kept alive
-    // until the parent finished working with it.
-    int write_fd = WritePipeFD();
-    char c = '\0';
-    rv = WriteFD(write_fd, &c, 1);
-    ASSERT_EQ(1, rv) << ErrnoMessage("write");
   }
 
   void MachMultiprocessChild() override {
     int write_fd = WritePipeFD();
 
     mach_vm_address_t address =
         reinterpret_cast<mach_vm_address_t>(kTestMemory);
-    ssize_t rv = WriteFD(write_fd, &address, sizeof(address));
-    ASSERT_EQ(static_cast<ssize_t>(sizeof(address)), rv)
-        << ErrnoMessage("write");
+    CheckedWriteFD(write_fd, &address, sizeof(address));
 
-    // Wait for the parent to say that it’s OK to exit.
-    int read_fd = ReadPipeFD();
-    char c;
-    rv = ReadFD(read_fd, &c, 1);
-    ASSERT_EQ(1, rv) << ErrnoMessage("read");
+    // Wait for the parent to signal that it’s OK to exit by closing its end of
+    // the pipe.
+    CheckedReadFDAtEOF(ReadPipeFD());
   }
 
   DISALLOW_COPY_AND_ASSIGN(ProcessReaderChild);
 };
 
 TEST(ProcessReader, ChildBasic) {
   ProcessReaderChild process_reader_child;
   process_reader_child.Run();
 }
 
@@ skipping 314 matching lines @@
     int read_fd = ReadPipeFD();
 
     // Build a map of all expected threads, keyed by each thread’s ID, and with
     // addresses that should lie somewhere within each thread’s stack as values.
     // These IDs and addresses all come from the child process via the pipe.
     ThreadMap thread_map;
     for (size_t thread_index = 0;
          thread_index < thread_count_ + 1;
          ++thread_index) {
       uint64_t thread_id;
-      ssize_t rv = ReadFD(read_fd, &thread_id, sizeof(thread_id));
-      ASSERT_EQ(static_cast<ssize_t>(sizeof(thread_id)), rv)
-          << ErrnoMessage("read");
+      CheckedReadFD(read_fd, &thread_id, sizeof(thread_id));
 
       TestThreadPool::ThreadExpectation expectation;
-      rv = ReadFD(read_fd,
-                  &expectation.stack_address,
-                  sizeof(expectation.stack_address));
-      ASSERT_EQ(static_cast<ssize_t>(sizeof(expectation.stack_address)), rv)
-          << ErrnoMessage("read");
-
-      rv = ReadFD(read_fd,
-                  &expectation.suspend_count,
-                  sizeof(expectation.suspend_count));
-      ASSERT_EQ(static_cast<ssize_t>(sizeof(expectation.suspend_count)), rv)
-          << ErrnoMessage("read");
+      CheckedReadFD(read_fd,
+                    &expectation.stack_address,
+                    sizeof(expectation.stack_address));
+      CheckedReadFD(read_fd,
+                    &expectation.suspend_count,
+                    sizeof(expectation.suspend_count));
 
       // There can’t be any duplicate thread IDs.
       EXPECT_EQ(0u, thread_map.count(thread_id));
 
       thread_map[thread_id] = expectation;
     }
 
     const std::vector<ProcessReader::Thread>& threads = process_reader.Threads();
 
     // The child shouldn’t have any threads other than its main thread and the
     // ones it created in its pool, so pass false for |tolerate_extra_threads|.
     ExpectSeveralThreads(&thread_map, threads, false);
-
-    // Tell the child that it’s OK to exit. The child needed to be kept alive
-    // until the parent finished working with it.
-    int write_fd = WritePipeFD();
-    char c = '\0';
-    ssize_t rv = WriteFD(write_fd, &c, 1);

[Robert Sesek, 2014/09/18 19:02:14]

This delete was intentional because you're now relying on the pipe closing,
right?

[Mark Mentovai, 2014/09/18 19:03:11]

rsesek wrote:
Right!

-    ASSERT_EQ(1, rv) << ErrnoMessage("write");
   }
 
   void MachMultiprocessChild() override {
     TestThreadPool thread_pool;
     thread_pool.StartThreads(thread_count_);
     if (testing::Test::HasFatalFailure()) {
       return;
     }
 
     int write_fd = WritePipeFD();
 
     // This thread isn’t part of the thread pool, but the parent will be able
     // to inspect it. Write an entry for it.
     uint64_t thread_id = PthreadToThreadID(pthread_self());
 
-    ssize_t rv = WriteFD(write_fd, &thread_id, sizeof(thread_id));
-    ASSERT_EQ(static_cast<ssize_t>(sizeof(thread_id)), rv)
-        << ErrnoMessage("write");
+    CheckedWriteFD(write_fd, &thread_id, sizeof(thread_id));
 
     TestThreadPool::ThreadExpectation expectation;
     expectation.stack_address = reinterpret_cast<mach_vm_address_t>(&thread_id);
     expectation.suspend_count = 0;
 
-    rv = WriteFD(write_fd,
-                 &expectation.stack_address,
-                 sizeof(expectation.stack_address));
-    ASSERT_EQ(static_cast<ssize_t>(sizeof(expectation.stack_address)), rv)
-        << ErrnoMessage("write");
-
-    rv = WriteFD(write_fd,
-                 &expectation.suspend_count,
-                 sizeof(expectation.suspend_count));
-    ASSERT_EQ(static_cast<ssize_t>(sizeof(expectation.suspend_count)), rv)
-        << ErrnoMessage("write");
+    CheckedWriteFD(write_fd,
+                   &expectation.stack_address,
+                   sizeof(expectation.stack_address));
+    CheckedWriteFD(write_fd,
+                   &expectation.suspend_count,
+                   sizeof(expectation.suspend_count));
 
     // Write an entry for everything in the thread pool.
     for (size_t thread_index = 0;
          thread_index < thread_count_;
          ++thread_index) {
       uint64_t thread_id =
           thread_pool.GetThreadInfo(thread_index, &expectation);
 
-      rv = WriteFD(write_fd, &thread_id, sizeof(thread_id));
-      ASSERT_EQ(static_cast<ssize_t>(sizeof(thread_id)), rv)
-          << ErrnoMessage("write");
-
-      rv = WriteFD(write_fd,
-                   &expectation.stack_address,
-                   sizeof(expectation.stack_address));
-      ASSERT_EQ(static_cast<ssize_t>(sizeof(expectation.stack_address)), rv)
-          << ErrnoMessage("write");
-
-      rv = WriteFD(write_fd,
-                   &expectation.suspend_count,
-                   sizeof(expectation.suspend_count));
-      ASSERT_EQ(static_cast<ssize_t>(sizeof(expectation.suspend_count)), rv)
-          << ErrnoMessage("write");
+      CheckedWriteFD(write_fd, &thread_id, sizeof(thread_id));
+      CheckedWriteFD(write_fd,
+                     &expectation.stack_address,
+                     sizeof(expectation.stack_address));
+      CheckedWriteFD(write_fd,
+                     &expectation.suspend_count,
+                     sizeof(expectation.suspend_count));
     }
 
-    // Wait for the parent to say that it’s OK to exit.
-    int read_fd = ReadPipeFD();
-    char c;
-    rv = ReadFD(read_fd, &c, 1);
-    ASSERT_EQ(1, rv) << ErrnoMessage("read");
+    // Wait for the parent to signal that it’s OK to exit by closing its end of
+    // the pipe.
+    CheckedReadFDAtEOF(ReadPipeFD());
   }
 
   size_t thread_count_;
 
   DISALLOW_COPY_AND_ASSIGN(ProcessReaderThreadedChild);
 };
 
 TEST(ProcessReader, ChildOneThread) {
   // The main thread plus zero child threads equals one thread.
   const size_t kChildThreads = 0;
@@ skipping 76 matching lines @@
     const std::vector<ProcessReader::Module>& modules =
         process_reader.Modules();
 
     // There needs to be at least an entry for the main executable, for a dylib,
     // and for dyld.
     ASSERT_GE(modules.size(), 3u);
 
     int read_fd = ReadPipeFD();
 
     uint32_t expect_modules;
-    ssize_t rv = ReadFD(read_fd, &expect_modules, sizeof(expect_modules));
-    ASSERT_EQ(static_cast<ssize_t>(sizeof(expect_modules)), rv)
-        << ErrnoMessage("read");
+    CheckedReadFD(read_fd, &expect_modules, sizeof(expect_modules));
 
     ASSERT_EQ(expect_modules, modules.size());
 
     for (size_t index = 0; index < modules.size(); ++index) {
       SCOPED_TRACE(base::StringPrintf(
           "index %zu, name %s", index, modules[index].name.c_str()));
 
       uint32_t expect_name_length;
-      rv = ReadFD(
+      CheckedReadFD(
           read_fd, &expect_name_length, sizeof(expect_name_length));
-      ASSERT_EQ(static_cast<ssize_t>(sizeof(expect_name_length)), rv)
-          << ErrnoMessage("read");
 
       // The NUL terminator is not read.
       std::string expect_name(expect_name_length, '\0');
-      rv = ReadFD(read_fd, &expect_name[0], expect_name_length);
-      ASSERT_EQ(static_cast<ssize_t>(expect_name_length), rv)
-          << ErrnoMessage("read");
-
+      CheckedReadFD(read_fd, &expect_name[0], expect_name_length);
       EXPECT_EQ(expect_name, modules[index].name);
 
       mach_vm_address_t expect_address;
-      rv = ReadFD(read_fd, &expect_address, sizeof(expect_address));
-      ASSERT_EQ(static_cast<ssize_t>(sizeof(expect_address)), rv)
-          << ErrnoMessage("read");
-
+      CheckedReadFD(read_fd, &expect_address, sizeof(expect_address));
       EXPECT_EQ(expect_address, modules[index].address);
 
       if (index == 0 || index == modules.size() - 1) {
         // dyld didn’t load the main executable or itself, so it couldn’t record
         // these timestamps, and they are reported as 0.
         EXPECT_EQ(0, modules[index].timestamp);
       } else {
         // Hope that the module didn’t change on disk.
         struct stat stat_buf;
         int rv = stat(expect_name.c_str(), &stat_buf);
         EXPECT_EQ(0, rv) << ErrnoMessage("stat");
         if (rv == 0) {
           EXPECT_EQ(stat_buf.st_mtime, modules[index].timestamp);
         }
       }
     }
-
-    // Tell the child that it’s OK to exit. The child needed to be kept alive
-    // until the parent finished working with it.
-    int write_fd = WritePipeFD();
-    char c = '\0';
-    rv = WriteFD(write_fd, &c, 1);
-    ASSERT_EQ(1, rv) << ErrnoMessage("write");
   }
 
   void MachMultiprocessChild() override {
     int write_fd = WritePipeFD();
 
     uint32_t dyld_image_count = _dyld_image_count();
     const struct dyld_all_image_infos* dyld_image_infos =
         _dyld_get_all_image_infos();
 
     uint32_t write_image_count = dyld_image_count;
     if (dyld_image_infos->version >= 2) {
       // dyld_image_count doesn’t include an entry for dyld itself, but one will
       // be written.
       ++write_image_count;
     }
 
-    ssize_t rv = WriteFD(
-        write_fd, &write_image_count, sizeof(write_image_count));
-    ASSERT_EQ(static_cast<ssize_t>(sizeof(write_image_count)), rv)
-        << ErrnoMessage("write");
+    CheckedWriteFD(write_fd, &write_image_count, sizeof(write_image_count));
 
     for (size_t index = 0; index < write_image_count; ++index) {
       const char* dyld_image_name;
       mach_vm_address_t dyld_image_address;
 
       if (index < dyld_image_count) {
         dyld_image_name = _dyld_get_image_name(index);
         dyld_image_address =
             reinterpret_cast<mach_vm_address_t>(_dyld_get_image_header(index));
       } else {
         dyld_image_name = "/usr/lib/dyld";
         dyld_image_address = reinterpret_cast<mach_vm_address_t>(
             dyld_image_infos->dyldImageLoadAddress);
       }
 
       uint32_t dyld_image_name_length = strlen(dyld_image_name);
-      rv = WriteFD(
+      CheckedWriteFD(
           write_fd, &dyld_image_name_length, sizeof(dyld_image_name_length));
-      ASSERT_EQ(static_cast<ssize_t>(sizeof(dyld_image_name_length)), rv)
-          << ErrnoMessage("write");
 
       // The NUL terminator is not written.
-      rv = WriteFD(write_fd, dyld_image_name, dyld_image_name_length);
-      ASSERT_EQ(static_cast<ssize_t>(dyld_image_name_length), rv)
-          << ErrnoMessage("write");
+      CheckedWriteFD(write_fd, dyld_image_name, dyld_image_name_length);
 
-      rv = WriteFD(write_fd, &dyld_image_address, sizeof(dyld_image_address));
-      ASSERT_EQ(static_cast<ssize_t>(sizeof(dyld_image_address)), rv)
-          << ErrnoMessage("write");
+      CheckedWriteFD(write_fd, &dyld_image_address, sizeof(dyld_image_address));
     }
 
-    // Wait for the parent to say that it’s OK to exit.
-    int read_fd = ReadPipeFD();
-    char c;
-    rv = ReadFD(read_fd, &c, 1);
-    ASSERT_EQ(1, rv) << ErrnoMessage("read");
+    // Wait for the parent to signal that it’s OK to exit by closing its end of
+    // the pipe.
+    CheckedReadFDAtEOF(ReadPipeFD());
   }
 
   DISALLOW_COPY_AND_ASSIGN(ProcessReaderModulesChild);
 };
 
 TEST(ProcessReader, ChildModules) {
   ProcessReaderModulesChild process_reader_modules_child;
   process_reader_modules_child.Run();
 }
 
 }  // namespace