mojo/embedder/platform_channel_utils_posix.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "mojo/embedder/platform_channel_utils_posix.h"
   6
   7 #include <sys/socket.h>
   8 #include <sys/uio.h>
   9 #include <unistd.h>
  10
  11 #include "base/logging.h"
  12 #include "base/posix/eintr_wrapper.h"
  13 #include "build/build_config.h"
  14
  15 namespace mojo {
  16 namespace embedder {
  17
  18 // On Linux, |SIGPIPE| is suppressed by passing |MSG_NOSIGNAL| to
  19 // |send()|/|sendmsg()|. (There is no way of suppressing |SIGPIPE| on
  20 // |write()|/|writev().) On Mac, |SIGPIPE| is suppressed by setting the
  21 // |SO_NOSIGPIPE| option on the socket.
  22 //
  23 // Performance notes:
  24 //  - On Linux, we have to use |send()|/|sendmsg()| rather than
  25 //    |write()|/|writev()| in order to suppress |SIGPIPE|. This is okay, since
  26 //    |send()| is (slightly) faster than |write()| (!), while |sendmsg()| is
  27 //    quite comparable to |writev()|.
  28 //  - On Mac, we may use |write()|/|writev()|. Here, |write()| is considerably
  29 //    faster than |send()|, whereas |sendmsg()| is quite comparable to
  30 //    |writev()|.
  31 //  - On both platforms, an appropriate |sendmsg()|/|writev()| is considerably
  32 //    faster than two |send()|s/|write()|s.
  33 //  - Relative numbers (minimum real times from 10 runs) for one |write()| of
  34 //    1032 bytes, one |send()| of 1032 bytes, one |writev()| of 32+1000 bytes,
  35 //    one |sendmsg()| of 32+1000 bytes, two |write()|s of 32 and 1000 bytes, two
  36 //    |send()|s of 32 and 1000 bytes:
  37 //    - Linux: 0.81 s, 0.77 s, 0.87 s, 0.89 s, 1.31 s, 1.22 s
  38 //    - Mac: 2.21 s, 2.91 s, 2.98 s, 3.08 s, 3.59 s, 4.74 s
  39
  40 // Flags to use with calling |send()| or |sendmsg()| (see above).
  41 #if defined(OS_MACOSX)
  42 const int kSendFlags = 0;
  43 #else
  44 const int kSendFlags = MSG_NOSIGNAL;
  45 #endif
  46
  47 ssize_t PlatformChannelWrite(PlatformHandle h,
  48                              const void* bytes,
  49                              size_t num_bytes) {
  50   DCHECK(h.is_valid());
  51   DCHECK(bytes);
  52   DCHECK_GT(num_bytes, 0u);
  53
  54 #if defined(OS_MACOSX)
  55   return HANDLE_EINTR(write(h.fd, bytes, num_bytes));
  56 #else
  57   return send(h.fd, bytes, num_bytes, kSendFlags);
  58 #endif
  59 }
  60
  61 ssize_t PlatformChannelWritev(PlatformHandle h,
  62                               struct iovec* iov,
  63                               size_t num_iov) {
  64   DCHECK(h.is_valid());
  65   DCHECK(iov);
  66   DCHECK_GT(num_iov, 0u);
  67
  68 #if defined(OS_MACOSX)
  69   return HANDLE_EINTR(writev(h.fd, iov, static_cast<int>(num_iov)));
  70 #else
  71   struct msghdr msg = {};
  72   msg.msg_iov = iov;
  73   msg.msg_iovlen = num_iov;
  74   return HANDLE_EINTR(sendmsg(h.fd, &msg, kSendFlags));
  75 #endif
  76 }
  77
  78 ssize_t PlatformChannelSendmsgWithHandles(PlatformHandle h,
  79                                           struct iovec* iov,
  80                                           size_t num_iov,
  81                                           PlatformHandle* platform_handles,
  82                                           size_t num_platform_handles) {
  83   DCHECK(iov);
  84   DCHECK_GT(num_iov, 0u);
  85   DCHECK(platform_handles);
  86   DCHECK_GT(num_platform_handles, 0u);
  87   DCHECK_LE(num_platform_handles, kPlatformChannelMaxNumHandles);
  88
  89   char cmsg_buf[CMSG_SPACE(kPlatformChannelMaxNumHandles * sizeof(int))];
  90   struct msghdr msg = {};
  91   msg.msg_iov = iov;
  92   msg.msg_iovlen = num_iov;
  93   msg.msg_control = cmsg_buf;
  94   msg.msg_controllen = CMSG_LEN(num_platform_handles * sizeof(int));
  95   struct cmsghdr* cmsg = CMSG_FIRSTHDR(&msg);
  96   cmsg->cmsg_level = SOL_SOCKET;
  97   cmsg->cmsg_type = SCM_RIGHTS;
  98   cmsg->cmsg_len = CMSG_LEN(num_platform_handles * sizeof(int));
  99   for (size_t i = 0; i < num_platform_handles; i++) {
 100     DCHECK(platform_handles[i].is_valid());
 101     reinterpret_cast<int*>(CMSG_DATA(cmsg))[i] = platform_handles[i].fd;
 102   }
 103
 104   return HANDLE_EINTR(sendmsg(h.fd, &msg, kSendFlags));
 105 }
 106
 107 bool PlatformChannelSendHandles(PlatformHandle h,
 108                                 PlatformHandle* handles,
 109                                 size_t num_handles) {
 110   DCHECK(handles);
 111   DCHECK_GT(num_handles, 0u);
 112   DCHECK_LE(num_handles, kPlatformChannelMaxNumHandles);
 113
 114   // Note: |sendmsg()| fails on Mac if we don't write at least one character.
 115   struct iovec iov = {const_cast<char*>(""), 1};
 116   char cmsg_buf[CMSG_SPACE(kPlatformChannelMaxNumHandles * sizeof(int))];
 117   struct msghdr msg = {};
 118   msg.msg_iov = &iov;
 119   msg.msg_iovlen = 1;
 120   msg.msg_control = cmsg_buf;
 121   msg.msg_controllen = CMSG_LEN(num_handles * sizeof(int));
 122   struct cmsghdr* cmsg = CMSG_FIRSTHDR(&msg);
 123   cmsg->cmsg_level = SOL_SOCKET;
 124   cmsg->cmsg_type = SCM_RIGHTS;
 125   cmsg->cmsg_len = CMSG_LEN(num_handles * sizeof(int));
 126   for (size_t i = 0; i < num_handles; i++) {
 127     DCHECK(handles[i].is_valid());
 128     reinterpret_cast<int*>(CMSG_DATA(cmsg))[i] = handles[i].fd;
 129   }
 130
 131   ssize_t result = HANDLE_EINTR(sendmsg(h.fd, &msg, kSendFlags));
 132   if (result < 1) {
 133     DCHECK_EQ(result, -1);
 134     return false;
 135   }
 136
 137   for (size_t i = 0; i < num_handles; i++)
 138     handles[i].CloseIfNecessary();
 139   return true;
 140 }
 141
 142 ssize_t PlatformChannelRecvmsg(PlatformHandle h,
 143                                void* buf,
 144                                size_t num_bytes,
 145                                std::deque<PlatformHandle>* platform_handles) {
 146   DCHECK(buf);
 147   DCHECK_GT(num_bytes, 0u);
 148   DCHECK(platform_handles);
 149
 150   struct iovec iov = {buf, num_bytes};
 151   char cmsg_buf[CMSG_SPACE(kPlatformChannelMaxNumHandles * sizeof(int))];
 152   struct msghdr msg = {};
 153   msg.msg_iov = &iov;
 154   msg.msg_iovlen = 1;
 155   msg.msg_control = cmsg_buf;
 156   msg.msg_controllen = sizeof(cmsg_buf);
 157
 158   ssize_t result = HANDLE_EINTR(recvmsg(h.fd, &msg, MSG_DONTWAIT));
 159   if (result < 0)
 160     return result;
 161
 162   // Success; no control messages.
 163   if (msg.msg_controllen == 0)
 164     return result;
 165
 166   DCHECK(!(msg.msg_flags & MSG_CTRUNC));
 167
 168   for (cmsghdr* cmsg = CMSG_FIRSTHDR(&msg); cmsg;
 169        cmsg = CMSG_NXTHDR(&msg, cmsg)) {
 170     if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) {
 171       size_t payload_length = cmsg->cmsg_len - CMSG_LEN(0);
 172       DCHECK_EQ(payload_length % sizeof(int), 0u);
 173       size_t num_fds = payload_length / sizeof(int);
 174       const int* fds = reinterpret_cast<int*>(CMSG_DATA(cmsg));
 175       for (size_t i = 0; i < num_fds; i++) {
 176         platform_handles->push_back(PlatformHandle(fds[i]));
 177         DCHECK(platform_handles->back().is_valid());
 178       }
 179     }
 180   }
 181
 182   return result;
 183 }
 184
 185 }  // namespace embedder
 186 }  // namespace mojo