iotop/taskstats.cpp

   1 // Copyright (C) 2015 The Android Open Source Project
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //      http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 #include <linux/taskstats.h>
  16 #include <netlink/socket.h>
  17 #include <netlink/genl/ctrl.h>
  18 #include <netlink/genl/genl.h>
  19
  20 #include <algorithm>
  21 #include <memory>
  22
  23 #include <android-base/logging.h>
  24
  25 #include "taskstats.h"
  26
  27 TaskstatsSocket::TaskstatsSocket()
  28     : nl_(nullptr, nl_socket_free), family_id_(0) {
  29 }
  30
  31 bool TaskstatsSocket::Open() {
  32   std::unique_ptr<nl_sock, decltype(&nl_socket_free)> nl(
  33       nl_socket_alloc(), nl_socket_free);
  34   if (!nl.get()) {
  35     LOG(ERROR) << "Failed to allocate netlink socket";
  36     return false;
  37   }
  38
  39   int ret = genl_connect(nl.get());
  40   if (ret < 0) {
  41     LOG(ERROR) << nl_geterror(ret) << std::endl << "Unable to open netlink socket (are you root?)";
  42     return false;
  43   }
  44
  45   int family_id = genl_ctrl_resolve(nl.get(), TASKSTATS_GENL_NAME);
  46   if (family_id < 0) {
  47     LOG(ERROR) << nl_geterror(family_id) << std::endl << "Unable to determine taskstats family id (does your kernel support taskstats?)";
  48     return false;
  49   }
  50
  51   nl_ = std::move(nl);
  52   family_id_ = family_id;
  53
  54   return true;
  55 }
  56
  57 void TaskstatsSocket::Close() {
  58   nl_.reset();
  59 }
  60
  61 struct TaskStatsRequest {
  62   pid_t requested_pid;
  63   taskstats stats;
  64 };
  65
  66 static pid_t ParseAggregateTaskStats(nlattr* attr, int attr_size,
  67                                      taskstats* stats) {
  68   pid_t received_pid = -1;
  69   nla_for_each_attr(attr, attr, attr_size, attr_size) {
  70     switch (nla_type(attr)) {
  71     case TASKSTATS_TYPE_PID:
  72     case TASKSTATS_TYPE_TGID:
  73       received_pid = nla_get_u32(attr);
  74       break;
  75     case TASKSTATS_TYPE_STATS:
  76     {
  77       int len = static_cast<int>(sizeof(*stats));
  78       len = std::min(len, nla_len(attr));
  79       nla_memcpy(stats, attr, len);
  80       return received_pid;
  81     }
  82     default:
  83       LOG(ERROR) << "unexpected attribute inside AGGR";
  84       return -1;
  85     }
  86   }
  87
  88   return -1;
  89 }
  90
  91 static int ParseTaskStats(nl_msg* msg, void* arg) {
  92   TaskStatsRequest* taskstats_request = static_cast<TaskStatsRequest*>(arg);
  93   genlmsghdr* gnlh = static_cast<genlmsghdr*>(nlmsg_data(nlmsg_hdr(msg)));
  94   nlattr* attr = genlmsg_attrdata(gnlh, 0);
  95   int remaining = genlmsg_attrlen(gnlh, 0);
  96
  97   nla_for_each_attr(attr, attr, remaining, remaining) {
  98     switch (nla_type(attr)) {
  99     case TASKSTATS_TYPE_AGGR_PID:
 100     case TASKSTATS_TYPE_AGGR_TGID:
 101     {
 102       nlattr* nested_attr = static_cast<nlattr*>(nla_data(attr));
 103       taskstats stats;
 104       pid_t ret;
 105
 106       ret = ParseAggregateTaskStats(nested_attr, nla_len(attr), &stats);
 107       if (ret < 0) {
 108         LOG(ERROR) << "Bad AGGR_PID contents";
 109       } else if (ret == taskstats_request->requested_pid) {
 110         taskstats_request->stats = stats;
 111       } else {
 112         LOG(WARNING) << "got taskstats for unexpected pid " << ret <<
 113             " (expected " << taskstats_request->requested_pid << ", continuing...";
 114       }
 115       break;
 116     }
 117     case TASKSTATS_TYPE_NULL:
 118       break;
 119     default:
 120       LOG(ERROR) << "unexpected attribute in taskstats";
 121     }
 122   }
 123   return NL_OK;
 124 }
 125
 126 bool TaskstatsSocket::GetStats(int pid, int type, TaskStatistics& stats) {
 127   TaskStatsRequest taskstats_request = TaskStatsRequest();
 128   taskstats_request.requested_pid = pid;
 129
 130   std::unique_ptr<nl_msg, decltype(&nlmsg_free)> message(nlmsg_alloc(),
 131                                                          nlmsg_free);
 132
 133   genlmsg_put(message.get(), NL_AUTO_PID, NL_AUTO_SEQ, family_id_, 0, 0,
 134               TASKSTATS_CMD_GET, TASKSTATS_VERSION);
 135   nla_put_u32(message.get(), type, pid);
 136
 137   int result = nl_send_auto_complete(nl_.get(), message.get());
 138   if (result < 0) {
 139     return false;
 140   }
 141
 142   std::unique_ptr<nl_cb, decltype(&nl_cb_put)> callbacks(
 143       nl_cb_alloc(NL_CB_DEFAULT), nl_cb_put);
 144   nl_cb_set(callbacks.get(), NL_CB_VALID, NL_CB_CUSTOM, &ParseTaskStats,
 145             static_cast<void*>(&taskstats_request));
 146
 147   result = nl_recvmsgs(nl_.get(), callbacks.get());
 148   if (result < 0) {
 149     return false;
 150   }
 151   nl_wait_for_ack(nl_.get());
 152
 153   stats = TaskStatistics(taskstats_request.stats);
 154
 155   return true;
 156 }
 157
 158 bool TaskstatsSocket::GetPidStats(int pid, TaskStatistics& stats) {
 159   return GetStats(pid, TASKSTATS_CMD_ATTR_PID, stats);
 160 }
 161
 162 bool TaskstatsSocket::GetTgidStats(int tgid, TaskStatistics& stats) {
 163   bool ret = GetStats(tgid, TASKSTATS_CMD_ATTR_TGID, stats);
 164   if (ret) {
 165     stats.set_pid(tgid);
 166   }
 167   return ret;
 168 }
 169
 170 TaskStatistics::TaskStatistics(const taskstats& taskstats_stats) {
 171   comm_ = std::string(taskstats_stats.ac_comm);
 172   pid_ = taskstats_stats.ac_pid;
 173
 174   uid_ = taskstats_stats.ac_uid;
 175   gid_ = taskstats_stats.ac_gid;
 176   pid_ = taskstats_stats.ac_pid;
 177   ppid_ = taskstats_stats.ac_ppid;
 178
 179   cpu_delay_count_ = taskstats_stats.cpu_count;
 180   cpu_delay_ns_ = taskstats_stats.cpu_delay_total;
 181
 182   block_io_delay_count_ = taskstats_stats.blkio_count;
 183   block_io_delay_ns_ = taskstats_stats.blkio_delay_total;
 184
 185   swap_in_delay_count_ = taskstats_stats.swapin_count;
 186   swap_in_delay_ns_ = taskstats_stats.swapin_delay_total;
 187
 188   reclaim_delay_count_ = taskstats_stats.freepages_count;
 189   reclaim_delay_ns_ = taskstats_stats.freepages_delay_total;
 190
 191   total_delay_ns_ =
 192       cpu_delay_ns_ + block_io_delay_ns_ + swap_in_delay_ns_ + reclaim_delay_ns_;
 193
 194   cpu_time_real_ = taskstats_stats.cpu_run_real_total;
 195   cpu_time_virtual_ = taskstats_stats.cpu_run_virtual_total;
 196
 197   read_bytes_ = taskstats_stats.read_bytes;
 198   write_bytes_ = taskstats_stats.write_bytes;
 199   read_write_bytes_ = read_bytes_ + write_bytes_;
 200   cancelled_write_bytes_ = taskstats_stats.cancelled_write_bytes;
 201   threads_ = 1;
 202 }
 203
 204 void TaskStatistics::AddPidToTgid(const TaskStatistics& pid_statistics) {
 205   // tgid statistics already contain delay values totalled across all pids
 206   // only add IO statistics
 207   read_bytes_            += pid_statistics.read_bytes_;
 208   write_bytes_           += pid_statistics.write_bytes_;
 209   read_write_bytes_      += pid_statistics.read_write_bytes_;
 210   cancelled_write_bytes_ += pid_statistics.cancelled_write_bytes_;
 211   if (pid_ == pid_statistics.pid_) {
 212     comm_ = pid_statistics.comm_;
 213     uid_ = pid_statistics.uid_;
 214     gid_ = pid_statistics.pid_;
 215     ppid_ = pid_statistics.ppid_;
 216   } else {
 217     threads_++;
 218   }
 219 }
 220
 221 // Store new statistics and return the delta from the old statistics
 222 TaskStatistics TaskStatistics::Update(const TaskStatistics& new_statistics) {
 223   TaskStatistics delta = new_statistics;
 224   delta.cpu_delay_count_       -= cpu_delay_count_;
 225   delta.cpu_delay_ns_          -= cpu_delay_ns_;
 226   delta.block_io_delay_count_  -= block_io_delay_count_;
 227   delta.block_io_delay_ns_     -= block_io_delay_ns_;
 228   delta.swap_in_delay_count_   -= swap_in_delay_count_;
 229   delta.swap_in_delay_ns_      -= swap_in_delay_ns_;
 230   delta.reclaim_delay_count_   -= reclaim_delay_count_;
 231   delta.reclaim_delay_ns_      -= reclaim_delay_ns_;
 232   delta.total_delay_ns_        -= total_delay_ns_;
 233   delta.cpu_time_real_         -= cpu_time_real_;
 234   delta.cpu_time_virtual_      -= cpu_time_virtual_;
 235   delta.read_bytes_            -= read_bytes_;
 236   delta.write_bytes_           -= write_bytes_;
 237   delta.read_write_bytes_      -= read_write_bytes_;
 238   delta.cancelled_write_bytes_ -= cancelled_write_bytes_;
 239   *this = new_statistics;
 240   return delta;
 241 }