lustre/utils/ltrack_stats.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  * GPL HEADER START
   5  *
   6  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 only,
  10  * as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License version 2 for more details (a copy is included
  16  * in the LICENSE file that accompanied this code).
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * version 2 along with this program; If not, see
  20  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
  21  *
  22  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  23  * CA 95054 USA or visit www.sun.com if you need additional information or
  24  * have any questions.
  25  *
  26  * GPL HEADER END
  27  */
  28 /*
  29  * Copyright  2008 Sun Microsystems, Inc. All rights reserved
  30  * Use is subject to license terms.
  31  */
  32 /*
  33  * This file is part of Lustre, http://www.lustre.org/
  34  * Lustre is a trademark of Sun Microsystems, Inc.
  35  *
  36  * lustre/utils/ltrack_stats.c
  37  *
  38  * Author: Milind Dumbare <milind@clusterfs.com>
  39  */
  40
  41 #include <sys/types.h>
  42 #include <sys/wait.h>
  43 #include <getopt.h>
  44 #include <stdio.h>
  45 #include <unistd.h>
  46 #include <glob.h>
  47 #include <signal.h>
  48 #include <string.h>
  49 #include <stdlib.h>
  50
  51
  52 #define TRACK_BY_GID 0
  53 #define TRACK_BY_PPID 1
  54 #define TRACK_BY_PID 2
  55 #define TRACK_FOR_ALL 3
  56
  57 /* We can have at the most 1024 llstats monitoring 1024 lustre clients
  58  * at a time */
  59 #define NO_OF_CLIENTS 1024
  60
  61 /* length of absolute path of vfs_ops_stats */
  62 #define LEN_STATS 1024
  63
  64 /* Length of llstat command with all its switches and command line options */
  65 #define LEN_LLSTAT (25 + LEN_STATS)
  66
  67 /* strlen of each lustre client entry in /proc/fs/lustre/llite/ */
  68 #define LEN_CLIENT 1024
  69
  70 /* size of output of llstat command we read at a time */
  71 #define MAX 1024
  72
  73 /* max strlen of outfile we get on command line */
  74 #define LEN_OUT 1024
  75
  76 /* Length of command given on command line */
  77 #define COMM_LEN 4096
  78 pid_t llstat[1024];
  79
  80 /* print usage */
  81 void print_usage()
  82 {
  83         printf("Usage:\n\n");
  84         printf("ltrack_stats runs command given and does one of the "
  85                 "following:\n"
  86                 "\t1. Writes its pid to "
  87                 "/proc/fs/lustre/llite/.../stats_track_pid\n"
  88                 " to collects stats for that process.\n"
  89                 "\t2. Writes its ppid to "
  90                 "/proc/fs/lustre/llite/.../stats_track_ppid\n"
  91                 " to collect stats of that process and all its children \n"
  92                 "\t3. Sets gid of process to some random gid (444) and also\n"
  93                 " writes that to/proc/fs/lustre/llite/.../stats_track_gid to"
  94                 " collect stats \nof all processes in that group\n\n"
  95                 " It also uses llstat to generate output with interval of 1 "
  96                 " second and duration\n of run of command for plot-llstat to "
  97                 "generate a graph\n\n");
  98         printf("ltrack_stats [-l filename] [-g <gid> | -a | -i | -c | -h ]\n"
  99                "\t<command with arguments ...>\n\n");
 100         printf("-l: outputs the llstat.pl's output to given <filename>"
 101                "with interval of 1 second \nbetween each output and flag for"
 102                "graphable output. If -l flag is not given llstat \nwont be"
 103                "executed\n\n");
 104
 105         printf("-g: for displaying VFS operation statistics collected"
 106                "for all processes having \ngroup id as given <gid> \n\n");
 107
 108         printf("-a: for displaying VFS operations statistics collected"
 109                "for all processes\n\n");
 110
 111         printf("-i: for displaying VFS operation statistics collected"
 112                "for only given <command's> \nPID.\n\n");
 113
 114         printf("-c: for displaying VFS operation statistics collected"
 115                " for all processes whose \nparents' PID is same as pid of "
 116                "<command> to be executed\n\n");
 117
 118         printf("-h: for showing this help\n");
 119 }
 120
 121 /* - type: to which file data should be written to track VFS operations
 122  * statistics
 123  * - id: we either need to write gid which is given on command line or pid
 124  * to collect statistics of that process or its children. */
 125
 126 void write_track_xid(int type, unsigned short id, char* stats_path)
 127 {
 128         FILE *fp;
 129
 130         /* for loop is used if we have more than one lustre clients on same
 131          * machine. glob() return /proc entry for each lustre client */
 132
 133         switch(type) {
 134                 case TRACK_BY_GID:
 135                         strcat(stats_path, "/stats_track_gid");
 136                         break;
 137                 case TRACK_BY_PPID:
 138                         strcat(stats_path, "/stats_track_ppid");
 139                         break;
 140                 case TRACK_BY_PID:
 141                         strcat(stats_path, "/stats_track_pid");
 142                         break;
 143         }
 144
 145         fp = fopen(stats_path, "w+");
 146         if (!fp) {
 147                 fprintf(stderr, "Error: Couldn't open /proc entry file: %s\n",
 148                         stats_path);
 149                 exit(1);
 150         }
 151         if (fprintf(fp, "%d", id) < 0) {
 152                 fprintf(stderr, "Error: Couldn't write id to tracking /proc"
 153                         "entry file: %s\n", stats_path);
 154                 exit(1);
 155         }
 156         if (fclose(fp)) {
 157                 fprintf(stderr, "Error: Couldn't close tracking /proc entry"
 158                         " file: %s\n", stats_path);
 159                 exit(1);
 160         }
 161 }
 162
 163 /* Get extra command lines concatenated to "command Function getopt scans
 164  *  one switch and its optional argument. So if command line is
 165  * "-g 1234 make bzImage" 1234 is optarg and "make bzImage" will be collected
 166  *  with following function to exec it. */
 167 char* get_command_from_argv(int optind, int argc, char** argv,char* optarg,
 168                             char* command)
 169 {
 170         int index = 0;
 171
 172         strcpy(command, optarg);
 173         strcat(command, " ");
 174         for (index = optind; index < argc; index++) {
 175                 strcat(command, argv[index]);
 176                 strcat(command, " ");
 177         }
 178         if (strlen(command) == 1) {
 179                 fprintf(stderr,"Error: command missing \n");
 180                 print_usage();
 181                 exit(1);
 182         } else if (strlen(command) > COMM_LEN) {
 183                 fprintf(stderr,"Error: Too long command \n");
 184                 print_usage();
 185                 exit(1);
 186         }
 187
 188         return command;
 189 }
 190
 191 /* Check for the llstat command in $PATH env variable. */
 192 void check_llstat()
 193 {
 194         int status;
 195
 196         status = system("which llstat.pl &> /dev/null");
 197         if (status) {
 198                 fprintf(stderr,"Error: llstat.pl not found in PATH\n");
 199                 exit(1);
 200         }
 201 }
 202
 203 pid_t fork_llstat_command(char* llstat_file,char* stats_path)
 204 {
 205         char truncate_command[100];
 206         char llstat_command[LEN_LLSTAT];
 207         pid_t pid_llstat_command;
 208         FILE *fp_popen, *fp_out;
 209         char buffer[MAX];
 210
 211         /* Truncating llstat output file as it will be opened in while
 212          * loop to append output */
 213         sprintf(truncate_command,"> %s",llstat_file);
 214         system(truncate_command);
 215
 216         strcat(stats_path, "/stats");
 217
 218         /* creating a string of llstat command to give to
 219          * popen */
 220         sprintf(llstat_command, "llstat -i 1 -g %s ",
 221                 stats_path);
 222
 223         /* fork for llstat */
 224         if ((pid_llstat_command = fork()) < 0)
 225                 fprintf(stderr, "Error: Fork error\n");
 226
 227         /* in child (llstat) */
 228         if (pid_llstat_command == 0) {
 229                 /* Doing popen for llstat command */
 230                 fp_popen = popen(llstat_command, "r");
 231                 if (fp_popen == NULL) {
 232                         fprintf(stderr,"Couldn't popen the llstat command:"
 233                                 "\"%s\"n", llstat_command);
 234                         exit(1);
 235                 }
 236                 while (fgets(buffer, 1024, fp_popen) != NULL) {
 237                         /* Following code should be in while loop as llstat
 238                          * will keep on sending output each second and will
 239                          * not exit on itself. It will be killed when we finsh
 240                          * with our command so we must make the output file
 241                          * consistent after writing each 1024 bytes chunk */
 242
 243                         /* opening file where llstat will write its output */
 244                         fp_out = fopen(llstat_file, "a");
 245                         if (!fp_out) {
 246                                 fprintf(stderr, "Error: Couldn't open llstat"
 247                                         "outfile file: %s\n",
 248                                         llstat_file);
 249                                 exit(1);
 250                         }
 251                         /* fgets reads the popen output and fprintf writes it to
 252                          * output file */
 253
 254                         if (fputs(buffer, fp_out) == EOF) {
 255                                  fprintf(stderr, "Error: Couldn't write output"
 256                                          "of llstat to out file\n");
 257                                  exit(1);
 258                         }
 259
 260                         /* closing file opened for storing llstat's output */
 261                         if (fclose(fp_out)) {
 262                                 fprintf(stderr, "Error: Couldn't close llstat"
 263                                         "outfile: %s\n", llstat_file);
 264                                 exit(1);
 265                         }
 266                 }
 267                 /* closing popen for llstat */
 268                 if (pclose(fp_popen) < 0) {
 269                         fprintf(stderr, "Error: Couldn't pclos"
 270                                 " llstat popen call\n");
 271                         exit(1);
 272                 }
 273         } /* child ends */
 274         return pid_llstat_command;
 275 }
 276
 277 pid_t fork_actual_command(int type, unsigned short id, char* stats_path,
 278                           char* command)
 279 {
 280         pid_t pid;
 281
 282         /* starting ltrack_stats functionality here */
 283         if ((pid = fork()) < 0)
 284                 fprintf(stderr, "Error: Fork error\n");
 285
 286         /* fork for executing command */
 287         if (pid == 0) {
 288                 switch(type) {
 289                         case TRACK_BY_GID:
 290                                 if (setgid(id) < 0) {
 291                                         fprintf(stderr, "Error: failed to"
 292                                                " setgid\n");
 293                                         exit(1);
 294                                 }
 295                                 pid = id;
 296                                 break;
 297
 298                         case TRACK_BY_PID:
 299                         case TRACK_BY_PPID:
 300                                 pid = getpid();
 301                                 break;
 302
 303                         /* 0 has to be written to vfs_track_pid to collect
 304                          * statistics of all processes */
 305                         case TRACK_FOR_ALL:
 306                                 pid = 0;
 307                                 type = TRACK_BY_PID;
 308                                 break;
 309                 }
 310                 write_track_xid(type, pid, stats_path);
 311                 execl("/bin/sh", "sh", "-c", command, (char *)0);
 312                 exit(0);
 313         } /* child ends */
 314
 315         return(pid);
 316 }
 317
 318 char* get_path_stats(int with_llstat, char* stats_path)
 319 {
 320         glob_t stats_glob_buffer;
 321         int choice;
 322         char error = 0;
 323         int i;
 324
 325         /* No slots reserved in gl_pathv. Store the found path at 0 location */
 326         stats_glob_buffer.gl_offs = 0;
 327
 328         /* doing glob() for attaching llstat to monitor each vfs_ops_stat for
 329          * mulitiple lustre clients */
 330         if (glob("/proc/fs/lustre/llite/*", GLOB_DOOFFS, NULL,
 331                  &stats_glob_buffer) != 0) {
 332                 fprintf(stderr,"Error: Couldn't find /proc entry for "
 333                         "lustre\n");
 334                 exit(1);
 335         }
 336
 337         /* If multiple client entries found in /proc/fs/lustre/llite user will
 338          * be prompted with choice of all */
 339         if (stats_glob_buffer.gl_pathc > 1 && with_llstat) {
 340                 check_llstat();
 341                 printf("Multiple lustre clients found, continuing... \n");
 342                 do {
 343                         /* If flow is here again it means there was an error
 344                          * and notifying that to user */
 345                         if (error) {
 346                                 system("clear");
 347                                 fprintf(stderr, "Error: Please give correct "
 348                                         "choice.\n");
 349                         }
 350                         /* Simple menu based interface to avoid possible
 351                          * spelling mistakes */
 352                         printf("\t\tMenu.\n");
 353                         for (i = 0; i < stats_glob_buffer.gl_pathc; i++)
 354                                 printf("\t\t%d. %s\n", i+1,
 355                                        stats_glob_buffer.gl_pathv[i]);
 356
 357                         printf("\nEnter the lustre client number you want to "
 358                                "use:");
 359                         scanf(" %d", &choice);
 360                         error ++;
 361                 } while (choice > stats_glob_buffer.gl_pathc || choice < 1);
 362                 strcpy(stats_path, stats_glob_buffer.gl_pathv[choice - 1]);
 363         } else {
 364                 /*if only one client then simply copying the path from glob */
 365                 strcpy(stats_path, stats_glob_buffer.gl_pathv[0]);
 366         }
 367         /* this frees dynamically allocated space by glob() for storing found
 368          * paths */
 369         globfree(&stats_glob_buffer);
 370
 371         return stats_path;
 372 }
 373
 374 /* Writes the id (gid/ pid/ ppid) value in appropriate tracking proc entry file
 375  * and EXECs the command given */
 376 void fork_command(int type, unsigned short id, char* command, char* llstat_file)
 377 {
 378         pid_t pid_actual_command = 0;
 379         pid_t pid_llstat_command = 0;
 380
 381         /* counters */
 382         int with_llstat = 1;
 383         int status;
 384         char stats_path[1024];
 385         char stats_path_temp[1024];
 386
 387         if (strlen(llstat_file) == 0)
 388                 with_llstat = 0;
 389
 390         get_path_stats(with_llstat, stats_path);
 391         strcpy(stats_path_temp, stats_path);
 392
 393         /* llstat process attached to monitor given command */
 394         if (with_llstat)
 395                 pid_llstat_command = fork_llstat_command(llstat_file,
 396                                                          stats_path_temp);
 397
 398         /* forking a process which will exec command given */
 399         pid_actual_command = fork_actual_command(type, id, stats_path,
 400                                                  command);
 401
 402         if (waitpid(pid_actual_command, NULL, 0) != pid_actual_command)
 403                 fprintf(stderr, "Error: waitpid error\n");
 404
 405         if (with_llstat) {
 406                 /* comment #25 of BUG 10968 */
 407                 sleep(2);
 408
 409                 /* sending kill to all llstat commands created for each
 410                  * lustre-client respectively */
 411                 kill(pid_llstat_command, 9);
 412                 waitpid(pid_llstat_command, &status, 0);
 413
 414                 /* if llstat child is killed by KILL only then print note for
 415                  * plotting graph and if its exited normally with errornous
 416                  * status then it means there were some error and llstat was
 417                  * aborted*/
 418                 if (!WIFEXITED(status))
 419                         printf("\n\t[Note: Do \"$plot-llstat %s\" to plot a graph"
 420                                " using GNU plot]\n", llstat_file);
 421
 422         }
 423 }
 424
 425 /* main */
 426 int main(int argc, char **argv)
 427 {
 428         char gid_string[5] = "";
 429         gid_t gid;
 430         int c;
 431         char command[COMM_LEN] = "";
 432         char llstat_file[100] = "";
 433
 434         /* Checking for root*/
 435         if (getuid()) {
 436                 fprintf(stderr, "Error: You need to be root\n");
 437                 exit(1);
 438         }
 439
 440         opterr = 0;
 441         /* Parsing command line switches */
 442         while ((c = getopt(argc, argv, "l:g:c:i:a:h")) != 1)
 443                 switch (c) {
 444                         case 'l':
 445                                 strcpy(llstat_file, optarg);
 446                                 if (strlen(llstat_file) > LEN_OUT) {
 447                                         fprintf(stderr, "length of outfile file"
 448                                                 " is too long\n");
 449                                         exit(1);
 450                                 }
 451                                 break;
 452
 453                         /* When any value is written to vfs_track_gid, then VFS
 454                          * operation statistics are collected for all
 455                          * processes of that group ID.
 456                          * write_track_xid writes given <gid> in vfs_track_gid
 457                          * here. */
 458                         case 'g':
 459                                 strcpy(gid_string, optarg);
 460                                 get_command_from_argv(optind, argc, argv, "",
 461                                                       command);
 462                                 gid = atoi(gid_string);
 463
 464                                 fork_command(TRACK_BY_GID, gid, command,
 465                                              llstat_file);
 466                                 return(0);
 467
 468                         /* When any value is written to vfs_track_ppid, then VFS
 469                          * operation statistics are collected for all processes
 470                          * whose parents' PID is same as track_ppid.
 471                          *- write_track_xid writes pid to vfs_track_ppid here */
 472                         case 'c':
 473                                 get_command_from_argv(optind, argc, argv,
 474                                                       optarg, command);
 475                                 fork_command(TRACK_BY_PPID, 0, command,
 476                                              llstat_file);
 477                                 return(0);
 478
 479                         /* When a non-zero value is written to vfs_track_pid,
 480                          * then VFS operation statistics are collected for only
 481                          * that PID.Write_track_xid writes pid to vfs_track_pid
 482                          * here.Wei need to FORK a new process and EXEC it with
 483                          * given <command>. */
 484                         case 'i':
 485                                 get_command_from_argv(optind, argc, argv,
 486                                                       optarg, command);
 487                                 fork_command(TRACK_BY_PID, 0, command,
 488                                              llstat_file);
 489                                 return(0);
 490
 491                         /* When VFS operation statistics for all processes are
 492                          * to be collected, "0" is written to vfs_track_pid. */
 493                         case 'a':
 494                                 get_command_from_argv(optind, argc, argv,
 495                                                       optarg, command);
 496                                 fork_command(TRACK_FOR_ALL, 0, command,
 497                                              llstat_file);
 498                                 return(0);
 499
 500                         /* Help */
 501                         case 'h':
 502                                 print_usage();
 503                                 return(0);
 504
 505                         default:
 506                                 print_usage();
 507                                 return(1);
 508                 }
 509         return(0);
 510 } /* main ends */