lustre/portals/utils/debug.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  * Copyright (C) 2001, 2002 Cluster File Systems, Inc.
   5  *
   6  *   This file is part of Portals, http://www.sf.net/projects/lustre/
   7  *
   8  *   Portals is free software; you can redistribute it and/or
   9  *   modify it under the terms of version 2 of the GNU General Public
  10  *   License as published by the Free Software Foundation.
  11  *
  12  *   Portals is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *   GNU General Public License for more details.
  16  *
  17  *   You should have received a copy of the GNU General Public License
  18  *   along with Portals; if not, write to the Free Software
  19  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  *
  21  * Some day I'll split all of this functionality into a cfs_debug module
  22  * of its own.  That day is not today.
  23  *
  24  */
  25
  26 #define __USE_FILE_OFFSET64
  27
  28 #include <stdio.h>
  29 #include <netdb.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <fcntl.h>
  33 #include <errno.h>
  34 #include <unistd.h>
  35 #include <time.h>
  36 #ifndef __CYGWIN__
  37 # include <syscall.h>
  38 #endif
  39
  40 #include <sys/types.h>
  41 #include <sys/socket.h>
  42 #include <sys/ioctl.h>
  43 #include <sys/stat.h>
  44 #include <sys/mman.h>
  45
  46 #include <linux/version.h>
  47
  48 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
  49 #define BUG()                            /* workaround for module.h includes */
  50 #include <linux/module.h>
  51 #endif
  52
  53 #include <portals/api-support.h>
  54 #include <portals/ptlctl.h>
  55 #include "parser.h"
  56
  57 static char rawbuf[8192];
  58 static char *buf = rawbuf;
  59 static int max = 8192;
  60 //static int g_pfd = -1;
  61 static int subsystem_mask = ~0;
  62 static int debug_mask = ~0;
  63
  64 #define MAX_MARK_SIZE 100
  65
  66 static const char *portal_debug_subsystems[] =
  67         {"undefined", "mdc", "mds", "osc", "ost", "class", "log", "llite",
  68          "rpc", "mgmt", "portals", "libcfs", "socknal", "qswnal", "pinger",
  69          "filter", "ptlbd", "echo", "ldlm", "lov", "gmnal", "router", "cobd",
  70          "ibnal", "lmv", "smfs", "cmobd", NULL};
  71 static const char *portal_debug_masks[] =
  72         {"trace", "inode", "super", "ext2", "malloc", "cache", "info", "ioctl",
  73          "blocks", "net", "warning", "buffs", "other", "dentry", "portals",
  74          "page", "dlmtrace", "error", "emerg", "ha", "rpctrace", "vfstrace",
  75          "reada", NULL};
  76
  77 struct debug_daemon_cmd {
  78         char *cmd;
  79         unsigned int cmdv;
  80 };
  81
  82 static const struct debug_daemon_cmd portal_debug_daemon_cmd[] = {
  83         {"start", DEBUG_DAEMON_START},
  84         {"stop", DEBUG_DAEMON_STOP},
  85         {"pause", DEBUG_DAEMON_PAUSE},
  86         {"continue", DEBUG_DAEMON_CONTINUE},
  87         {0, 0}
  88 };
  89
  90 static int do_debug_mask(char *name, int enable)
  91 {
  92         int found = 0, i;
  93
  94         for (i = 0; portal_debug_subsystems[i] != NULL; i++) {
  95                 if (strcasecmp(name, portal_debug_subsystems[i]) == 0 ||
  96                     strcasecmp(name, "all_subs") == 0) {
  97                         printf("%s output from subsystem \"%s\"\n",
  98                                 enable ? "Enabling" : "Disabling",
  99                                 portal_debug_subsystems[i]);
 100                         if (enable)
 101                                 subsystem_mask |= (1 << i);
 102                         else
 103                                 subsystem_mask &= ~(1 << i);
 104                         found = 1;
 105                 }
 106         }
 107         for (i = 0; portal_debug_masks[i] != NULL; i++) {
 108                 if (strcasecmp(name, portal_debug_masks[i]) == 0 ||
 109                     strcasecmp(name, "all_types") == 0) {
 110                         printf("%s output of type \"%s\"\n",
 111                                 enable ? "Enabling" : "Disabling",
 112                                 portal_debug_masks[i]);
 113                         if (enable)
 114                                 debug_mask |= (1 << i);
 115                         else
 116                                 debug_mask &= ~(1 << i);
 117                         found = 1;
 118                 }
 119         }
 120
 121         return found;
 122 }
 123
 124 int dbg_initialize(int argc, char **argv)
 125 {
 126         return 0;
 127 }
 128
 129 int jt_dbg_filter(int argc, char **argv)
 130 {
 131         int   i;
 132
 133         if (argc < 2) {
 134                 fprintf(stderr, "usage: %s <subsystem ID or debug mask>\n",
 135                         argv[0]);
 136                 return 0;
 137         }
 138
 139         for (i = 1; i < argc; i++)
 140                 if (!do_debug_mask(argv[i], 0))
 141                         fprintf(stderr, "Unknown subsystem or debug type: %s\n",
 142                                 argv[i]);
 143         return 0;
 144 }
 145
 146 int jt_dbg_show(int argc, char **argv)
 147 {
 148         int    i;
 149
 150         if (argc < 2) {
 151                 fprintf(stderr, "usage: %s <subsystem ID or debug mask>\n",
 152                         argv[0]);
 153                 return 0;
 154         }
 155
 156         for (i = 1; i < argc; i++)
 157                 if (!do_debug_mask(argv[i], 1))
 158                         fprintf(stderr, "Unknown subsystem or debug type: %s\n",
 159                                 argv[i]);
 160
 161         return 0;
 162 }
 163
 164 static int applymask(char* procpath, int value)
 165 {
 166         int rc;
 167         char buf[64];
 168         int len = snprintf(buf, 64, "%d", value);
 169
 170         int fd = open(procpath, O_WRONLY);
 171         if (fd == -1) {
 172                 fprintf(stderr, "Unable to open %s: %s\n",
 173                         procpath, strerror(errno));
 174                 return fd;
 175         }
 176         rc = write(fd, buf, len+1);
 177         if (rc<0) {
 178                 fprintf(stderr, "Write to %s failed: %s\n",
 179                         procpath, strerror(errno));
 180                 return rc;
 181         }
 182         close(fd);
 183         return 0;
 184 }
 185
 186 static void applymask_all(unsigned int subs_mask, unsigned int debug_mask)
 187 {
 188         if (!dump_filename) {
 189                 applymask("/proc/sys/portals/subsystem_debug", subs_mask);
 190                 applymask("/proc/sys/portals/debug", debug_mask);
 191         } else {
 192                 struct portals_debug_ioctl_data data;
 193
 194                 data.hdr.ioc_len = sizeof(data);
 195                 data.hdr.ioc_version = 0;
 196                 data.subs = subs_mask;
 197                 data.debug = debug_mask;
 198
 199                 dump(OBD_DEV_ID, PTL_IOC_DEBUG_MASK, &data);
 200         }
 201         printf("Applied subsystem_debug=%d, debug=%d to /proc/sys/portals\n",
 202                subs_mask, debug_mask);
 203 }
 204
 205 int jt_dbg_list(int argc, char **argv)
 206 {
 207         int i;
 208
 209         if (argc != 2) {
 210                 fprintf(stderr, "usage: %s <subs || types>\n", argv[0]);
 211                 return 0;
 212         }
 213
 214         if (strcasecmp(argv[1], "subs") == 0) {
 215                 printf("Subsystems: all_subs");
 216                 for (i = 0; portal_debug_subsystems[i] != NULL; i++)
 217                         printf(", %s", portal_debug_subsystems[i]);
 218                 printf("\n");
 219         } else if (strcasecmp(argv[1], "types") == 0) {
 220                 printf("Types: all_types");
 221                 for (i = 0; portal_debug_masks[i] != NULL; i++)
 222                         printf(", %s", portal_debug_masks[i]);
 223                 printf("\n");
 224         } else if (strcasecmp(argv[1], "applymasks") == 0) {
 225                 applymask_all(subsystem_mask, debug_mask);
 226         }
 227         return 0;
 228 }
 229
 230 /* if 'raw' is true, don't strip the debug information from the front of the
 231  * lines */
 232 static void dump_buffer(FILE *fd, char *buf, int size, int raw)
 233 {
 234         char *p, *z;
 235         unsigned long subsystem, debug, dropped = 0, kept = 0;
 236
 237         while (size) {
 238                 p = memchr(buf, '\n', size);
 239                 if (!p)
 240                         break;
 241                 subsystem = strtoul(buf, &z, 16);
 242                 debug = strtoul(z + 1, &z, 16);
 243
 244                 z++;
 245                 /* for some reason %*s isn't working. */
 246                 *p = '\0';
 247                 if ((subsystem_mask & subsystem) &&
 248                     (!debug || (debug_mask & debug))) {
 249                         if (raw)
 250                                 fprintf(fd, "%s\n", buf);
 251                         else
 252                                 fprintf(fd, "%s\n", z);
 253                         //printf("%s\n", buf);
 254                         kept++;
 255                 } else {
 256                         //fprintf(stderr, "dropping line (%lx:%lx): %s\n", subsystem, debug, buf);
 257                         dropped++;
 258                 }
 259                 *p = '\n';
 260                 p++;
 261                 size -= (p - buf);
 262                 buf = p;
 263         }
 264
 265         printf("Debug log: %lu lines, %lu kept, %lu dropped.\n",
 266                 dropped + kept, kept, dropped);
 267 }
 268
 269 int jt_dbg_debug_kernel(int argc, char **argv)
 270 {
 271         int rc, raw = 1;
 272         FILE *fd = stdout;
 273         const int databuf_size = (6 << 20);
 274         struct portal_ioctl_data data, *newdata;
 275         char *databuf = NULL;
 276
 277         if (argc > 3) {
 278                 fprintf(stderr, "usage: %s [file] [raw]\n", argv[0]);
 279                 return 0;
 280         }
 281
 282         if (argc > 1) {
 283                 fd = fopen(argv[1], "w");
 284                 if (fd == NULL) {
 285                         fprintf(stderr, "fopen(%s) failed: %s\n", argv[1],
 286                                 strerror(errno));
 287                         return -1;
 288                 }
 289         }
 290         if (argc > 2)
 291                 raw = atoi(argv[2]);
 292
 293         databuf = malloc(databuf_size);
 294         if (!databuf) {
 295                 fprintf(stderr, "No memory for buffer.\n");
 296                 goto out;
 297         }
 298
 299         memset(&data, 0, sizeof(data));
 300         data.ioc_plen1 = databuf_size;
 301         data.ioc_pbuf1 = databuf;
 302
 303         if (portal_ioctl_pack(&data, &buf, max) != 0) {
 304                 fprintf(stderr, "portal_ioctl_pack failed.\n");
 305                 goto out;
 306         }
 307
 308         rc = l_ioctl(PORTALS_DEV_ID, IOC_PORTAL_GET_DEBUG, buf);
 309         if (rc) {
 310                 fprintf(stderr, "IOC_PORTAL_GET_DEBUG failed: %s\n",
 311                         strerror(errno));
 312                 goto out;
 313         }
 314
 315         newdata = (struct portal_ioctl_data *)buf;
 316         if (newdata->ioc_size > 0)
 317                 dump_buffer(fd, databuf, newdata->ioc_size, raw);
 318
 319  out:
 320         if (databuf)
 321                 free(databuf);
 322         if (fd != stdout)
 323                 fclose(fd);
 324         return 0;
 325 }
 326
 327 int jt_dbg_debug_daemon(int argc, char **argv)
 328 {
 329         int i, rc;
 330         unsigned int cmd = 0;
 331         FILE *fd = stdout;
 332         struct portal_ioctl_data data;
 333
 334         if (argc <= 1) {
 335                 fprintf(stderr, "usage: %s [start file <#MB>|stop|pause|"
 336                         "continue]\n", argv[0]);
 337                 return 0;
 338         }
 339         for (i = 0; portal_debug_daemon_cmd[i].cmd != NULL; i++) {
 340                 if (strcasecmp(argv[1], portal_debug_daemon_cmd[i].cmd) == 0) {
 341                         cmd = portal_debug_daemon_cmd[i].cmdv;
 342                         break;
 343                 }
 344         }
 345         if (portal_debug_daemon_cmd[i].cmd == NULL) {
 346                 fprintf(stderr, "usage: %s [start file <#MB>|stop|pause|"
 347                         "continue]\n", argv[0]);
 348                 return 0;
 349         }
 350         memset(&data, 0, sizeof(data));
 351         if (cmd == DEBUG_DAEMON_START) {
 352                 if (argc < 3) {
 353                         fprintf(stderr, "usage: %s [start file <#MB>|stop|"
 354                                 "pause|continue]\n", argv[0]);
 355                         return 0;
 356                 }
 357                 if (access(argv[2], F_OK) != 0) {
 358                         fd = fopen(argv[2], "w");
 359                         if (fd != NULL) {
 360                                 fclose(fd);
 361                                 remove(argv[2]);
 362                                 goto ok;
 363                         }
 364                 }
 365                 if (access(argv[2], W_OK) == 0)
 366                         goto ok;
 367                 fprintf(stderr, "fopen(%s) failed: %s\n", argv[2],
 368                         strerror(errno));
 369                 return -1;
 370 ok:
 371                 data.ioc_inllen1 = strlen(argv[2]) + 1;
 372                 data.ioc_inlbuf1 = argv[2];
 373                 data.ioc_misc = 0;
 374                 if (argc == 4) {
 375                         unsigned long size;
 376                         errno = 0;
 377                         size = strtoul(argv[3], NULL, 0);
 378                         if (errno) {
 379                                 fprintf(stderr, "file size(%s): error %s\n",
 380                                         argv[3], strerror(errno));
 381                                 return -1;
 382                         }
 383                         data.ioc_misc = size;
 384                 }
 385         }
 386         data.ioc_count = cmd;
 387         if (portal_ioctl_pack(&data, &buf, max) != 0) {
 388                 fprintf(stderr, "portal_ioctl_pack failed.\n");
 389                 return -1;
 390         }
 391         rc = l_ioctl(PORTALS_DEV_ID, IOC_PORTAL_SET_DAEMON, buf);
 392         if (rc < 0) {
 393                 fprintf(stderr, "IOC_PORTAL_SET_DEMON failed: %s\n",
 394                                 strerror(errno));
 395                 return rc;
 396         }
 397         return 0;
 398 }
 399
 400 int jt_dbg_debug_file(int argc, char **argv)
 401 {
 402         int rc, fd = -1, raw = 1;
 403         FILE *output = stdout;
 404         char *databuf = NULL;
 405         struct stat statbuf;
 406
 407         if (argc > 4 || argc < 2) {
 408                 fprintf(stderr, "usage: %s <input> [output] [raw]\n", argv[0]);
 409                 return 0;
 410         }
 411
 412         fd = open(argv[1], O_RDONLY);
 413         if (fd < 0) {
 414                 fprintf(stderr, "fopen(%s) failed: %s\n", argv[1],
 415                         strerror(errno));
 416                 return -1;
 417         }
 418
 419         rc = fstat(fd, &statbuf);
 420         if (rc < 0) {
 421                 fprintf(stderr, "fstat failed: %s\n", strerror(errno));
 422                 goto out;
 423         }
 424
 425         if (argc >= 3) {
 426                 output = fopen(argv[2], "w");
 427                 if (output == NULL) {
 428                         fprintf(stderr, "fopen(%s) failed: %s\n", argv[2],
 429                                 strerror(errno));
 430                         goto out;
 431                 }
 432         }
 433
 434         if (argc == 4)
 435                 raw = atoi(argv[3]);
 436
 437         databuf = mmap(NULL, statbuf.st_size, PROT_READ | PROT_WRITE,
 438                        MAP_PRIVATE, fd, 0);
 439         if (databuf == NULL) {
 440                 fprintf(stderr, "mmap failed: %s\n", strerror(errno));
 441                 goto out;
 442         }
 443
 444         dump_buffer(output, databuf, statbuf.st_size, raw);
 445
 446  out:
 447         if (databuf)
 448                 munmap(databuf, statbuf.st_size);
 449         if (output != stdout)
 450                 fclose(output);
 451         if (fd > 0)
 452                 close(fd);
 453         return 0;
 454 }
 455
 456 int jt_dbg_clear_debug_buf(int argc, char **argv)
 457 {
 458         int rc;
 459         struct portal_ioctl_data data;
 460
 461         if (argc != 1) {
 462                 fprintf(stderr, "usage: %s\n", argv[0]);
 463                 return 0;
 464         }
 465
 466         memset(&data, 0, sizeof(data));
 467         if (portal_ioctl_pack(&data, &buf, max) != 0) {
 468                 fprintf(stderr, "portal_ioctl_pack failed.\n");
 469                 return -1;
 470         }
 471
 472         rc = l_ioctl(PORTALS_DEV_ID, IOC_PORTAL_CLEAR_DEBUG, buf);
 473         if (rc) {
 474                 fprintf(stderr, "IOC_PORTAL_CLEAR_DEBUG failed: %s\n",
 475                         strerror(errno));
 476                 return -1;
 477         }
 478         return 0;
 479 }
 480
 481 int jt_dbg_mark_debug_buf(int argc, char **argv)
 482 {
 483         int rc, max_size = MAX_MARK_SIZE-1;
 484         struct portal_ioctl_data data;
 485         char *text;
 486         time_t now = time(NULL);
 487
 488         if (argc > 1) {
 489                 int counter;
 490                 text = malloc(MAX_MARK_SIZE);
 491                 strncpy(text, argv[1], max_size);
 492                 max_size-=strlen(argv[1]);
 493                 for(counter = 2; (counter < argc) && (max_size > 0) ; counter++){
 494                         strncat(text, " ", 1);
 495                         max_size-=1;
 496                         strncat(text, argv[counter], max_size);
 497                         max_size-=strlen(argv[counter]);
 498                 }
 499         } else {
 500                 text = ctime(&now);
 501                 text[strlen(text) - 1] = '\0'; /* stupid \n */
 502         }
 503         if (!max_size) {
 504                 text[MAX_MARK_SIZE - 1] = '\0';
 505         }
 506
 507         memset(&data, 0, sizeof(data));
 508         data.ioc_inllen1 = strlen(text) + 1;
 509         data.ioc_inlbuf1 = text;
 510         if (portal_ioctl_pack(&data, &buf, max) != 0) {
 511                 fprintf(stderr, "portal_ioctl_pack failed.\n");
 512                 return -1;
 513         }
 514
 515         rc = l_ioctl(PORTALS_DEV_ID, IOC_PORTAL_MARK_DEBUG, buf);
 516         if (rc) {
 517                 fprintf(stderr, "IOC_PORTAL_MARK_DEBUG failed: %s\n",
 518                         strerror(errno));
 519                 return -1;
 520         }
 521         return 0;
 522 }
 523
 524 static struct mod_paths {
 525         char *name, *path;
 526 } mod_paths[] = {
 527         {"libcfs", "lustre/portals/libcfs"},
 528         {"portals", "lustre/portals/portals"},
 529         {"ksocknal", "lustre/portals/knals/socknal"},
 530         {"kptlrouter", "lustre/portals/router"},
 531         {"lvfs", "lustre/lvfs"},
 532         {"obdclass", "lustre/obdclass"},
 533         {"llog_test", "lustre/obdclass"},
 534         {"ptlrpc", "lustre/ptlrpc"},
 535         {"ost", "lustre/ost"},
 536         {"osc", "lustre/osc"},
 537         {"mds", "lustre/mds"},
 538         {"mdc", "lustre/mdc"},
 539         {"llite", "lustre/llite"},
 540         {"smfs", "lustre/smfs"},
 541         {"obdecho", "lustre/obdecho"},
 542         {"ldlm", "lustre/ldlm"},
 543         {"obdfilter", "lustre/obdfilter"},
 544         {"extN", "lustre/extN"},
 545         {"lov", "lustre/lov"},
 546         {"lmv", "lustre/lmv"},
 547         {"fsfilt_ext3", "lustre/lvfs"},
 548         {"fsfilt_extN", "lustre/lvfs"},
 549         {"fsfilt_reiserfs", "lustre/lvfs"},
 550         {"fsfilt_smfs", "lustre/lvfs"},
 551         {"ptlbd", "lustre/ptlbd"},
 552         {"mgmt_svc", "lustre/mgmt"},
 553         {"mgmt_cli", "lustre/mgmt"},
 554         {"cobd", "lustre/cobd"},
 555         {"cmobd", "lustre/cmobd"},
 556         {NULL, NULL}
 557 };
 558
 559 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
 560 int jt_dbg_modules(int argc, char **argv)
 561 {
 562         struct mod_paths *mp;
 563         char *path = "..";
 564         char *kernel = "linux";
 565
 566         if (argc >= 2)
 567                 path = argv[1];
 568         if (argc == 3)
 569                 kernel = argv[2];
 570         if (argc > 3) {
 571                 printf("%s [path] [kernel]\n", argv[0]);
 572                 return 0;
 573         }
 574
 575         for (mp = mod_paths; mp->name != NULL; mp++) {
 576                 struct module_info info;
 577                 int rc;
 578                 size_t crap;
 579                 int query_module(const char *name, int which, void *buf,
 580                                  size_t bufsize, size_t *ret);
 581
 582                 rc = query_module(mp->name, QM_INFO, &info, sizeof(info),
 583                                   &crap);
 584                 if (rc < 0) {
 585                         if (errno != ENOENT)
 586                                 printf("query_module(%s) failed: %s\n",
 587                                        mp->name, strerror(errno));
 588                 } else {
 589                         printf("add-symbol-file %s/%s/%s.o 0x%0lx\n", path,
 590                                mp->path, mp->name,
 591                                info.addr + sizeof(struct module));
 592                 }
 593         }
 594
 595         return 0;
 596 }
 597 #else
 598 int jt_dbg_modules(int argc, char **argv)
 599 {
 600         struct mod_paths *mp;
 601         char *path = "..";
 602         char *kernel = "linux";
 603         const char *proc = "/proc/modules";
 604         char modname[128], others[128];
 605         long modaddr;
 606         int rc;
 607         FILE *file;
 608
 609         if (argc >= 2)
 610                 path = argv[1];
 611         if (argc == 3)
 612                 kernel = argv[2];
 613         if (argc > 3) {
 614                 printf("%s [path] [kernel]\n", argv[0]);
 615                 return 0;
 616         }
 617
 618         file = fopen(proc, "r");
 619         if (!file) {
 620                 printf("failed open %s: %s\n", proc, strerror(errno));
 621                 return 0;
 622         }
 623
 624         while ((rc = fscanf(file, "%s %s %s %s %s %lx\n",
 625                 modname, others, others, others, others, &modaddr)) == 6) {
 626                 for (mp = mod_paths; mp->name != NULL; mp++) {
 627                         if (!strcmp(mp->name, modname))
 628                                 break;
 629                 }
 630                 if (mp->name) {
 631                         printf("add-symbol-file %s/%s/%s.o 0x%0lx\n", path,
 632                                mp->path, mp->name, modaddr);
 633                 }
 634         }
 635
 636         return 0;
 637 }
 638 #endif /* linux 2.5 */
 639
 640 int jt_dbg_panic(int argc, char **argv)
 641 {
 642         int rc;
 643         struct portal_ioctl_data data;
 644
 645         if (argc != 1) {
 646                 fprintf(stderr, "usage: %s\n", argv[0]);
 647                 return 0;
 648         }
 649
 650         memset(&data, 0, sizeof(data));
 651         if (portal_ioctl_pack(&data, &buf, max) != 0) {
 652                 fprintf(stderr, "portal_ioctl_pack failed.\n");
 653                 return -1;
 654         }
 655
 656         rc = l_ioctl(PORTALS_DEV_ID, IOC_PORTAL_PANIC, buf);
 657         if (rc) {
 658                 fprintf(stderr, "IOC_PORTAL_PANIC failed: %s\n",
 659                         strerror(errno));
 660                 return -1;
 661         }
 662         return 0;
 663 }