taskstats/taskstats.c

   1 /*
   2  * Copyright (C) 2013 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /*
  18  * Linux task stats reporting tool. Queries and prints out the kernel's
  19  * taskstats structure for a given process or thread group id. See
  20  * https://www.kernel.org/doc/Documentation/accounting/ for more information
  21  * about the reported fields.
  22  */
  23
  24 #include <errno.h>
  25 #include <getopt.h>
  26 #include <netlink/attr.h>
  27 #include <netlink/genl/genl.h>
  28 #include <netlink/genl/ctrl.h>
  29 #include <netlink/handlers.h>
  30 #include <netlink/msg.h>
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <sys/cdefs.h>
  34 #include <time.h>
  35 #include <unistd.h>
  36
  37 #include <linux/taskstats.h>
  38
  39 struct TaskStatistics {
  40     int pid;
  41     int tgid;
  42     struct taskstats stats;
  43 };
  44
  45 int print_receive_error(struct sockaddr_nl* address __unused,
  46                         struct nlmsgerr* error, void* arg __unused) {
  47     fprintf(stderr, "Netlink receive error: %s\n", strerror(-error->error));
  48     return NL_STOP;
  49 }
  50
  51 void parse_aggregate_task_stats(struct nlattr* attr, int attr_size,
  52                                 struct TaskStatistics* stats) {
  53     nla_for_each_attr(attr, attr, attr_size, attr_size) {
  54         switch (attr->nla_type) {
  55             case TASKSTATS_TYPE_PID:
  56                 stats->pid = nla_get_u32(attr);
  57                 break;
  58             case TASKSTATS_TYPE_TGID:
  59                 stats->tgid = nla_get_u32(attr);
  60                 break;
  61             case TASKSTATS_TYPE_STATS:
  62                 nla_memcpy(&stats->stats, attr, sizeof(stats->stats));
  63                 break;
  64             default:
  65                 break;
  66         }
  67     }
  68 }
  69
  70 int parse_task_stats(struct nl_msg* msg, void* arg) {
  71     struct TaskStatistics* stats = (struct TaskStatistics*)arg;
  72     struct genlmsghdr* gnlh = (struct genlmsghdr*)nlmsg_data(nlmsg_hdr(msg));
  73     struct nlattr* attr = genlmsg_attrdata(gnlh, 0);
  74     int remaining = genlmsg_attrlen(gnlh, 0);
  75
  76     nla_for_each_attr(attr, attr, remaining, remaining) {
  77         switch (attr->nla_type) {
  78             case TASKSTATS_TYPE_AGGR_PID:
  79             case TASKSTATS_TYPE_AGGR_TGID:
  80                 parse_aggregate_task_stats(nla_data(attr), nla_len(attr),
  81                                            stats);
  82                 break;
  83             default:
  84                 break;
  85         }
  86     }
  87     return NL_STOP;
  88 }
  89
  90 int query_task_stats(struct nl_sock* netlink_socket, int family_id,
  91                      int command_type, int parameter,
  92                      struct TaskStatistics* stats) {
  93     memset(stats, 0, sizeof(*stats));
  94
  95     struct nl_msg* message = nlmsg_alloc();
  96     genlmsg_put(message, NL_AUTO_PID, NL_AUTO_SEQ, family_id, 0, 0,
  97                 TASKSTATS_CMD_GET, TASKSTATS_VERSION);
  98     nla_put_u32(message, command_type, parameter);
  99
 100     int result = nl_send_auto_complete(netlink_socket, message);
 101     nlmsg_free(message);
 102     if (result < 0) {
 103         return result;
 104     }
 105
 106     struct nl_cb* callbacks = nl_cb_get(nl_cb_alloc(NL_CB_CUSTOM));
 107     nl_cb_set(callbacks, NL_CB_VALID, NL_CB_CUSTOM, &parse_task_stats, stats);
 108     nl_cb_err(callbacks, NL_CB_CUSTOM, &print_receive_error, &family_id);
 109
 110     result = nl_recvmsgs(netlink_socket, callbacks);
 111     nl_cb_put(callbacks);
 112     if (result < 0) {
 113         return result;
 114     }
 115     return stats->pid || stats->tgid;
 116 }
 117
 118 double average_ms(unsigned long long total, unsigned long long count) {
 119     if (!count) {
 120         return 0;
 121     }
 122     return ((double)total) / count / 1e6;
 123 }
 124
 125 unsigned long long average_ns(unsigned long long total,
 126                               unsigned long long count) {
 127     if (!count) {
 128         return 0;
 129     }
 130     return total / count;
 131 }
 132
 133 void print_task_stats(const struct TaskStatistics* stats,
 134                       int human_readable) {
 135     const struct taskstats* s = &stats->stats;
 136     printf("Basic task statistics\n");
 137     printf("---------------------\n");
 138     printf("%-25s%d\n", "Stats version:", s->version);
 139     printf("%-25s%d\n", "Exit code:", s->ac_exitcode);
 140     printf("%-25s0x%x\n", "Flags:", s->ac_flag);
 141     printf("%-25s%d\n", "Nice value:", s->ac_nice);
 142     printf("%-25s%s\n", "Command name:", s->ac_comm);
 143     printf("%-25s%d\n", "Scheduling discipline:", s->ac_sched);
 144     printf("%-25s%d\n", "UID:", s->ac_uid);
 145     printf("%-25s%d\n", "GID:", s->ac_gid);
 146     printf("%-25s%d\n", "PID:", s->ac_pid);
 147     printf("%-25s%d\n", "PPID:", s->ac_ppid);
 148
 149     if (human_readable) {
 150         time_t begin_time = s->ac_btime;
 151         printf("%-25s%s", "Begin time:", ctime(&begin_time));
 152     } else {
 153         printf("%-25s%d sec\n", "Begin time:", s->ac_btime);
 154     }
 155     printf("%-25s%llu usec\n", "Elapsed time:", s->ac_etime);
 156     printf("%-25s%llu usec\n", "User CPU time:", s->ac_utime);
 157     printf("%-25s%llu\n", "Minor page faults:", s->ac_minflt);
 158     printf("%-25s%llu\n", "Major page faults:", s->ac_majflt);
 159     printf("%-25s%llu usec\n", "Scaled user time:", s->ac_utimescaled);
 160     printf("%-25s%llu usec\n", "Scaled system time:", s->ac_stimescaled);
 161
 162     printf("\nDelay accounting\n");
 163     printf("----------------\n");
 164     printf("       %15s%15s%15s%15s%15s%15s\n",
 165            "Count",
 166            human_readable ? "Delay (ms)" : "Delay (ns)",
 167            "Average delay",
 168            "Real delay",
 169            "Scaled real",
 170            "Virtual delay");
 171
 172     if (!human_readable) {
 173         printf("CPU    %15llu%15llu%15llu%15llu%15llu%15llu\n",
 174                s->cpu_count,
 175                s->cpu_delay_total,
 176                average_ns(s->cpu_delay_total, s->cpu_count),
 177                s->cpu_run_real_total,
 178                s->cpu_scaled_run_real_total,
 179                s->cpu_run_virtual_total);
 180         printf("IO     %15llu%15llu%15llu\n",
 181                s->blkio_count,
 182                s->blkio_delay_total,
 183                average_ns(s->blkio_delay_total, s->blkio_count));
 184         printf("Swap   %15llu%15llu%15llu\n",
 185                s->swapin_count,
 186                s->swapin_delay_total,
 187                average_ns(s->swapin_delay_total, s->swapin_count));
 188         printf("Reclaim%15llu%15llu%15llu\n",
 189                s->freepages_count,
 190                s->freepages_delay_total,
 191                average_ns(s->freepages_delay_total, s->freepages_count));
 192     } else {
 193         const double ms_per_ns = 1e6;
 194         printf("CPU    %15llu%15.3f%15.3f%15.3f%15.3f%15.3f\n",
 195                s->cpu_count,
 196                s->cpu_delay_total / ms_per_ns,
 197                average_ms(s->cpu_delay_total, s->cpu_count),
 198                s->cpu_run_real_total / ms_per_ns,
 199                s->cpu_scaled_run_real_total / ms_per_ns,
 200                s->cpu_run_virtual_total / ms_per_ns);
 201         printf("IO     %15llu%15.3f%15.3f\n",
 202                s->blkio_count,
 203                s->blkio_delay_total / ms_per_ns,
 204                average_ms(s->blkio_delay_total, s->blkio_count));
 205         printf("Swap   %15llu%15.3f%15.3f\n",
 206                s->swapin_count,
 207                s->swapin_delay_total / ms_per_ns,
 208                average_ms(s->swapin_delay_total, s->swapin_count));
 209         printf("Reclaim%15llu%15.3f%15.3f\n",
 210                s->freepages_count,
 211                s->freepages_delay_total / ms_per_ns,
 212                average_ms(s->freepages_delay_total, s->freepages_count));
 213     }
 214
 215     printf("\nExtended accounting fields\n");
 216     printf("--------------------------\n");
 217     if (human_readable && s->ac_stime) {
 218         printf("%-25s%.3f MB\n", "Average RSS usage:",
 219                (double)s->coremem / s->ac_stime);
 220         printf("%-25s%.3f MB\n", "Average VM usage:",
 221                (double)s->virtmem / s->ac_stime);
 222     } else {
 223         printf("%-25s%llu MB\n", "Accumulated RSS usage:", s->coremem);
 224         printf("%-25s%llu MB\n", "Accumulated VM usage:", s->virtmem);
 225     }
 226     printf("%-25s%llu KB\n", "RSS high water mark:", s->hiwater_rss);
 227     printf("%-25s%llu KB\n", "VM high water mark:", s->hiwater_vm);
 228     printf("%-25s%llu\n", "IO bytes read:", s->read_char);
 229     printf("%-25s%llu\n", "IO bytes written:", s->write_char);
 230     printf("%-25s%llu\n", "IO read syscalls:", s->read_syscalls);
 231     printf("%-25s%llu\n", "IO write syscalls:", s->write_syscalls);
 232
 233     printf("\nPer-task/thread statistics\n");
 234     printf("--------------------------\n");
 235     printf("%-25s%llu\n", "Voluntary switches:", s->nvcsw);
 236     printf("%-25s%llu\n", "Involuntary switches:", s->nivcsw);
 237 }
 238
 239 void print_usage() {
 240   printf("Linux task stats reporting tool\n"
 241          "\n"
 242          "Usage: taskstats [options]\n"
 243          "\n"
 244          "Options:\n"
 245          "  --help        This text\n"
 246          "  --pid PID     Print stats for the process id PID\n"
 247          "  --tgid TGID   Print stats for the thread group id TGID\n"
 248          "  --raw         Print raw numbers instead of human readable units\n"
 249          "\n"
 250          "Either PID or TGID must be specified. For more documentation about "
 251          "the reported fields, see\n"
 252          "https://www.kernel.org/doc/Documentation/accounting/"
 253          "taskstats-struct.txt\n");
 254 }
 255
 256 int main(int argc, char** argv) {
 257     int command_type = 0;
 258     int pid = 0;
 259     int human_readable = 1;
 260
 261     const struct option long_options[] = {
 262         {"help", no_argument, 0, 0},
 263         {"pid", required_argument, 0, 0},
 264         {"tgid", required_argument, 0, 0},
 265         {"raw", no_argument, 0, 0},
 266         {0, 0, 0, 0}
 267     };
 268
 269     while (1) {
 270         int option_index;
 271         int option_char = getopt_long_only(argc, argv, "", long_options,
 272                                            &option_index);
 273         if (option_char == -1) {
 274             break;
 275         }
 276         switch (option_index) {
 277             case 0:
 278                 print_usage();
 279                 return EXIT_SUCCESS;
 280             case 1:
 281                 command_type = TASKSTATS_CMD_ATTR_PID;
 282                 pid = atoi(optarg);
 283                 break;
 284             case 2:
 285                 command_type = TASKSTATS_CMD_ATTR_TGID;
 286                 pid = atoi(optarg);
 287                 break;
 288             case 3:
 289                 human_readable = 0;
 290                 break;
 291             default:
 292                 break;
 293         };
 294     }
 295
 296     if (!pid) {
 297         printf("Either PID or TGID must be specified\n");
 298         return EXIT_FAILURE;
 299     }
 300
 301     struct nl_sock* netlink_socket = nl_socket_alloc();
 302     if (!netlink_socket) {
 303         fprintf(stderr, "Unable to allocate netlink socket\n");
 304         goto error;
 305     }
 306
 307     int ret = genl_connect(netlink_socket);
 308     if (ret < 0) {
 309         nl_perror(ret, "Unable to open netlink socket (are you root?)");
 310         goto error;
 311     }
 312
 313     int family_id = genl_ctrl_resolve(netlink_socket, TASKSTATS_GENL_NAME);
 314     if (family_id < 0) {
 315         nl_perror(family_id, "Unable to determine taskstats family id "
 316                "(does your kernel support taskstats?)");
 317         goto error;
 318     }
 319     struct TaskStatistics stats;
 320     ret = query_task_stats(netlink_socket, family_id, command_type, pid, &stats);
 321     if (ret < 0) {
 322         nl_perror(ret, "Failed to query taskstats");
 323         goto error;
 324     }
 325     print_task_stats(&stats, human_readable);
 326
 327     nl_socket_free(netlink_socket);
 328     return EXIT_SUCCESS;
 329
 330 error:
 331     if (netlink_socket) {
 332         nl_socket_free(netlink_socket);
 333     }
 334     return EXIT_FAILURE;
 335 }