lustre/utils/lr_reader.c

   1 /*
   2  * GPL HEADER START
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 only,
   8  * as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License version 2 for more details (a copy is included
  14  * in the LICENSE file that accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * version 2 along with this program; If not, see
  18  * http://www.gnu.org/licenses/gpl-2.0.html
  19  *
  20  * GPL HEADER END
  21  */
  22 /*
  23  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Use is subject to license terms.
  25  *
  26  * Copyright (c) 2013, Intel Corporation.
  27  */
  28 /*
  29  * This file is part of Lustre, http://www.lustre.org/
  30  * Lustre is a trademark of Sun Microsystems, Inc.
  31  *
  32  * lustre/utils/lr_reader.c
  33  *
  34  * Author: Nathan Rutman <nathan@clusterfs.com>
  35  */
  36  /* Safely read the last_rcvd file from a device */
  37
  38 #if HAVE_CONFIG_H
  39 #  include "config.h"
  40 #endif /* HAVE_CONFIG_H */
  41
  42 #ifndef _GNU_SOURCE
  43 #define _GNU_SOURCE
  44 #endif
  45 #include <errno.h>
  46 #include <limits.h>
  47 #include <stdbool.h>
  48 #include <stdlib.h>
  49 #include <stdio.h>
  50 #include <unistd.h>
  51 #include <fcntl.h>
  52 #include <stdarg.h>
  53 #include <mntent.h>
  54
  55 #include <sys/types.h>
  56 #include <sys/stat.h>
  57 #include <sys/mount.h>
  58
  59 #include <string.h>
  60 #include <getopt.h>
  61
  62 #include <asm/byteorder.h>
  63 #include <linux/lustre/lustre_disk.h>
  64 #include <linux/lustre/lustre_ver.h>
  65
  66 char *progname;
  67 static struct option const long_opts[] = {
  68         { .val = 'c',   .name = "client",       .has_arg = no_argument },
  69         { .val = 'h',   .name = "help",         .has_arg = no_argument },
  70         { .val = 'r',   .name = "reply",        .has_arg = no_argument },
  71         { .name = NULL } };
  72
  73 /* Executes the command \a cmd and returns command status.
  74  */
  75 int run_command(char *cmd, size_t cmdsz)
  76 {
  77         char log[] = "/tmp/run_command_logXXXXXX";
  78         int fd, rc;
  79
  80         if (strlen(cmd) + strlen(log) + 8 > cmdsz) {
  81                 fprintf(stderr, "Command buffer overflow: %.*s...\n",
  82                         (int)cmdsz, cmd);
  83                 return -ENOMEM;
  84         }
  85
  86         fd = mkstemp(log);
  87         if (fd >= 0) {
  88                 close(fd);
  89                 strncat(cmd, " >", cmdsz);
  90                 strncat(cmd, log, cmdsz);
  91         }
  92         strncat(cmd, " 2>&1", cmdsz - strlen(cmd));
  93
  94         /* Can't use popen because we need the rv of the command */
  95         rc = system(cmd);
  96         if (rc && fd >= 0) {
  97                 char buf[128];
  98                 FILE *fp;
  99                 fp = fopen(log, "r");
 100                 if (fp) {
 101                         while (fgets(buf, sizeof(buf), fp) != NULL) {
 102                                 if (rc)
 103                                         printf("   %s", buf);
 104                         }
 105                         fclose(fp);
 106                 }
 107         }
 108         if (fd >= 0)
 109                 remove(log);
 110         return rc;
 111 }
 112
 113
 114 void display_usage(void)
 115 {
 116         printf("Usage: %s [OPTIONS] devicename\n", progname);
 117         printf("Read and print the last_rcvd file from a device\n");
 118         printf("(safe for mounted devices)\n");
 119         printf("\t-c, --client, display client information\n");
 120         printf("\t-h, --help,   display this help and exit\n");
 121         printf("\t-r, --reply,  display reply data information\n");
 122 }
 123
 124
 125 int main(int argc, char *const argv[])
 126 {
 127         char tmpdir[] = "/tmp/dirXXXXXX";
 128         char cmd[128];
 129         char filepnm[128] = "";
 130         char *dev;
 131         struct lr_server_data lsd;
 132         FILE *filep = NULL;
 133         int ret;
 134         int c;
 135         int opt_client = 0;
 136         int opt_reply = 0;
 137
 138         progname = argv[0];
 139         while ((c = getopt_long(argc, argv, "chr", long_opts, NULL)) != -1) {
 140                 switch (c) {
 141                 case 'c':
 142                         opt_client = 1;
 143                         break;
 144                 case 'r':
 145                         opt_reply = 1;
 146                         break;
 147                 case 'h':
 148                 default:
 149                         display_usage();
 150                         return -1;
 151                 }
 152         }
 153         dev = argv[optind];
 154         if (!dev) {
 155                 display_usage();
 156                 return -1;
 157         }
 158
 159         /* Make a temporary directory to hold Lustre data files. */
 160         if (!mkdtemp(tmpdir)) {
 161                 fprintf(stderr, "%s: Can't create temporary directory %s: %s\n",
 162                         progname, tmpdir, strerror(errno));
 163                 return errno;
 164         }
 165
 166         memset(cmd, 0, sizeof(cmd));
 167         snprintf(cmd, sizeof(cmd),
 168                 "%s -c -R 'dump /%s %s/%s' %s",
 169                 DEBUGFS, LAST_RCVD, tmpdir, LAST_RCVD, dev);
 170
 171         ret = run_command(cmd, sizeof(cmd));
 172         if (ret) {
 173                 fprintf(stderr, "%s: Unable to dump %s file\n",
 174                         progname, LAST_RCVD);
 175                 goto out_rmdir;
 176         }
 177
 178         snprintf(filepnm, 128, "%s/%s", tmpdir, LAST_RCVD);
 179         filep = fopen(filepnm, "r");
 180         if (!filep) {
 181                 fprintf(stderr, "%s: Unable to read old data\n",
 182                         progname);
 183                 ret = -errno;
 184                 goto out_rmdir;
 185         }
 186         unlink(filepnm);
 187
 188         /* read lr_server_data structure */
 189         printf("%s:\n", LAST_RCVD);
 190         ret = fread(&lsd, 1, sizeof(lsd), filep);
 191         if (ret < sizeof(lsd)) {
 192                 fprintf(stderr, "%s: Short read (%d of %d)\n",
 193                         progname, ret, (int)sizeof(lsd));
 194                 ret = -ferror(filep);
 195                 if (ret)
 196                         goto out_close;
 197         }
 198
 199         /* swab structure fields of interest */
 200         lsd.lsd_feature_compat = __le32_to_cpu(lsd.lsd_feature_compat);
 201         lsd.lsd_feature_incompat = __le32_to_cpu(lsd.lsd_feature_incompat);
 202         lsd.lsd_feature_rocompat = __le32_to_cpu(lsd.lsd_feature_rocompat);
 203         lsd.lsd_last_transno = __le64_to_cpu(lsd.lsd_last_transno);
 204         lsd.lsd_osd_index = __le32_to_cpu(lsd.lsd_osd_index);
 205         lsd.lsd_mount_count = __le64_to_cpu(lsd.lsd_mount_count);
 206
 207         /* display */
 208         printf("  uuid: %.40s\n", lsd.lsd_uuid);
 209         printf("  feature_compat: %#x\n", lsd.lsd_feature_compat);
 210         printf("  feature_incompat: %#x\n", lsd.lsd_feature_incompat);
 211         printf("  feature_rocompat: %#x\n", lsd.lsd_feature_rocompat);
 212         printf("  last_transaction: %llu\n", lsd.lsd_last_transno);
 213         printf("  target_index: %u\n", lsd.lsd_osd_index);
 214         printf("  mount_count: %llu\n", lsd.lsd_mount_count);
 215
 216         /* read client information */
 217         if (opt_client) {
 218                 lsd.lsd_client_start = __le32_to_cpu(lsd.lsd_client_start);
 219                 lsd.lsd_client_size = __le16_to_cpu(lsd.lsd_client_size);
 220                 printf("  client_area_start: %u\n", lsd.lsd_client_start);
 221                 printf("  client_area_size: %hu\n", lsd.lsd_client_size);
 222
 223                 /* seek to per-client data area */
 224                 ret = fseek(filep, lsd.lsd_client_start, SEEK_SET);
 225                 if (ret) {
 226                         fprintf(stderr, "%s: seek failed. %s\n",
 227                                 progname, strerror(errno));
 228                         ret = errno;
 229                         goto out_close;
 230                 }
 231
 232                 /* walk throuh the per-client data area */
 233                 while (true) {
 234                         struct lsd_client_data lcd;
 235
 236                         /* read a per-client data area */
 237                         ret = fread(&lcd, 1, sizeof(lcd), filep);
 238                         if (ret < sizeof(lcd)) {
 239                                 if (feof(filep))
 240                                         break;
 241                                 fprintf(stderr, "%s: Short read (%d of %d)\n",
 242                                         progname, ret, (int)sizeof(lcd));
 243                                 ret = -ferror(filep);
 244                                 goto out_close;
 245                         }
 246
 247                         if (lcd.lcd_uuid[0] == '\0')
 248                                 continue;
 249
 250                         /* swab structure fields */
 251                         lcd.lcd_last_transno =
 252                                         __le64_to_cpu(lcd.lcd_last_transno);
 253                         lcd.lcd_last_xid = __le64_to_cpu(lcd.lcd_last_xid);
 254                         lcd.lcd_last_result = __le32_to_cpu(lcd.lcd_last_result);
 255                         lcd.lcd_last_data = __le32_to_cpu(lcd.lcd_last_data);
 256                         lcd.lcd_generation = __le32_to_cpu(lcd.lcd_generation);
 257
 258                         /* display per-client data area */
 259                         printf("\n  %.40s:\n", lcd.lcd_uuid);
 260                         printf("    generation: %u\n", lcd.lcd_generation);
 261                         printf("    last_transaction: %llu\n",
 262                                lcd.lcd_last_transno);
 263                         printf("    last_xid: %llu\n", lcd.lcd_last_xid);
 264                         printf("    last_result: %u\n", lcd.lcd_last_result);
 265                         printf("    last_data: %u\n", lcd.lcd_last_data);
 266
 267                         if (lcd.lcd_last_close_transno != 0 &&
 268                             lcd.lcd_last_close_xid != 0) {
 269                                 lcd.lcd_last_close_transno =
 270                                         __le64_to_cpu(lcd.lcd_last_close_transno);
 271                                 lcd.lcd_last_close_xid =
 272                                         __le64_to_cpu(lcd.lcd_last_close_xid);
 273                                 lcd.lcd_last_close_result =
 274                                         __le32_to_cpu(lcd.lcd_last_close_result);
 275                                 lcd.lcd_last_close_data =
 276                                         __le32_to_cpu(lcd.lcd_last_close_data);
 277                                 printf("    last_close_transation: %llu\n",
 278                                        lcd.lcd_last_close_transno);
 279                                 printf("    last_close_xid: %llu\n",
 280                                        lcd.lcd_last_close_xid);
 281                                 printf("    last_close_result: %u\n",
 282                                        lcd.lcd_last_close_result);
 283                                 printf("    last_close_data: %u\n",
 284                                        lcd.lcd_last_close_data);
 285                         }
 286                 }
 287         }
 288         fclose(filep);
 289         filep = NULL;
 290
 291         /* read reply data information */
 292         if (opt_reply) {
 293                 struct lsd_reply_header lrh;
 294                 struct lsd_reply_data lrd;
 295                 unsigned long long slot;
 296
 297                 snprintf(cmd, sizeof(cmd),
 298                          "%s -c -R 'dump /%s %s/%s' %s",
 299                          DEBUGFS, REPLY_DATA, tmpdir, REPLY_DATA, dev);
 300
 301                 ret = run_command(cmd, sizeof(cmd));
 302                 if (ret) {
 303                         fprintf(stderr, "%s: Unable to dump %s file\n",
 304                                 progname, REPLY_DATA);
 305                         goto out_rmdir;
 306                 }
 307
 308                 snprintf(filepnm, sizeof(filepnm),
 309                          "%s/%s", tmpdir, REPLY_DATA);
 310                 filep = fopen(filepnm, "r");
 311                 if (!filep) {
 312                         fprintf(stderr, "%s: Unable to read reply data\n",
 313                                 progname);
 314                         ret = -errno;
 315                         goto out_rmdir;
 316                 }
 317                 unlink(filepnm);
 318
 319                 /* read reply_data header */
 320                 printf("\n%s:\n", REPLY_DATA);
 321                 ret = fread(&lrh, 1, sizeof(lrh), filep);
 322                 if (ret < sizeof(lrh)) {
 323                         fprintf(stderr, "%s: Short read (%d of %d)\n",
 324                                 progname, ret, (int)sizeof(lrh));
 325                         ret = -ferror(filep);
 326                         if (ret)
 327                                 goto out_close;
 328                 }
 329
 330                 /* check header */
 331                 lrh.lrh_magic = __le32_to_cpu(lrh.lrh_magic);
 332                 lrh.lrh_header_size = __le32_to_cpu(lrh.lrh_header_size);
 333                 lrh.lrh_reply_size = __le32_to_cpu(lrh.lrh_reply_size);
 334                 if (lrh.lrh_magic != LRH_MAGIC) {
 335                         fprintf(stderr, "%s: invalid %s header: "
 336                                 "lrh_magic=%08x expected %08x\n",
 337                                 progname, REPLY_DATA, lrh.lrh_magic, LRH_MAGIC);
 338                         goto out_close;
 339                 }
 340                 if (lrh.lrh_header_size != sizeof(struct lsd_reply_header)) {
 341                         fprintf(stderr, "%s: invalid %s header: "
 342                                 "lrh_header_size=%08x expected %08x\n",
 343                                 progname, REPLY_DATA, lrh.lrh_header_size,
 344                                 (unsigned int)sizeof(struct lsd_reply_header));
 345                         goto out_close;
 346                 }
 347                 if (lrh.lrh_reply_size != sizeof(struct lsd_reply_data)) {
 348                         fprintf(stderr, "%s: invalid %s header: "
 349                                 "lrh_reply_size=%08x expected %08x\n",
 350                                 progname, REPLY_DATA, lrh.lrh_reply_size,
 351                                 (unsigned int)sizeof(struct lsd_reply_data));
 352                         goto out_close;
 353                 }
 354
 355                 /* walk throuh the reply data */
 356                 for (slot = 0; ; slot++) {
 357                         /* read a reply data */
 358                         ret = fread(&lrd, 1, sizeof(lrd), filep);
 359                         if (ret < sizeof(lrd)) {
 360                                 if (feof(filep))
 361                                         break;
 362                                 fprintf(stderr, "%s: Short read (%d of %d)\n",
 363                                         progname, ret, (int)sizeof(lrd));
 364                                 ret = -ferror(filep);
 365                                 goto out_close;
 366                         }
 367
 368                         /* display reply data */
 369                         lrd.lrd_transno = __le64_to_cpu(lrd.lrd_transno);
 370                         lrd.lrd_xid = __le64_to_cpu(lrd.lrd_xid);
 371                         lrd.lrd_data = __le64_to_cpu(lrd.lrd_data);
 372                         lrd.lrd_result = __le32_to_cpu(lrd.lrd_result);
 373                         lrd.lrd_client_gen = __le32_to_cpu(lrd.lrd_client_gen);
 374
 375                         printf("  %lld:\n", slot);
 376                         printf("    client_generation: %u\n",
 377                                lrd.lrd_client_gen);
 378                         printf("    last_transaction: %llu\n", lrd.lrd_transno);
 379                         printf("    last_xid: %llu\n", lrd.lrd_xid);
 380                         printf("    last_result: %u\n", lrd.lrd_result);
 381                         printf("    last_data: %llu\n\n", lrd.lrd_data);
 382                 }
 383         }
 384
 385 out_close:
 386         if (filep != NULL)
 387                 fclose(filep);
 388
 389 out_rmdir:
 390         rmdir(tmpdir);
 391         return ret;
 392 }