debugfs/xattrs.c

   1 /*
   2  * xattrs.c --- Modify extended attributes via debugfs.
   3  *
   4  * Copyright (C) 2014 Oracle.  This file may be redistributed
   5  * under the terms of the GNU Public License.
   6  */
   7
   8 #include "config.h"
   9 #include <stdio.h>
  10 #ifdef HAVE_GETOPT_H
  11 #include <getopt.h>
  12 #else
  13 extern int optind;
  14 extern char *optarg;
  15 #endif
  16 #include <ctype.h>
  17 #include "support/cstring.h"
  18
  19 #include "debugfs.h"
  20 #include "ext2fs/lfsck.h"
  21
  22 #define PRINT_XATTR_HEX         0x01
  23 #define PRINT_XATTR_RAW         0x02
  24 #define PRINT_XATTR_C           0x04
  25 #define PRINT_XATTR_STATFMT     0x08
  26 #define PRINT_XATTR_NOQUOTES    0x10
  27
  28 extern const char *debug_prog_name;
  29
  30 /* Dump extended attributes */
  31 static void print_xattr_hex(FILE *f, const char *str, int len)
  32 {
  33         int i;
  34
  35         for (i = 0; i < len; i++)
  36                 fprintf(f, "%02x ", (unsigned char)str[i]);
  37 }
  38
  39 /* Dump extended attributes */
  40 static void print_xattr_string(FILE *f, const char *str, int len, int flags)
  41 {
  42         int printable = 0;
  43         int i;
  44
  45         if (flags & PRINT_XATTR_RAW) {
  46                 fwrite(str, len, 1, f);
  47                 return;
  48         }
  49
  50         if ((flags & PRINT_XATTR_C) == 0) {
  51                 /* check: is string "printable enough?" */
  52                 for (i = 0; i < len; i++)
  53                         if (isprint(str[i]))
  54                                 printable++;
  55
  56                 if (printable <= len*7/8)
  57                         flags |= PRINT_XATTR_HEX;
  58         }
  59
  60         if (flags & PRINT_XATTR_HEX) {
  61                 print_xattr_hex(f, str, len);
  62         } else {
  63                 if ((flags & PRINT_XATTR_NOQUOTES) == 0)
  64                         fputc('\"', f);
  65                 print_c_string(f, str, len);
  66                 if ((flags & PRINT_XATTR_NOQUOTES) == 0)
  67                         fputc('\"', f);
  68         }
  69 }
  70
  71 static void print_xattr(FILE *f, char *name, char *value, size_t value_len,
  72                         int print_flags)
  73 {
  74         print_xattr_string(f, name, strlen(name), PRINT_XATTR_NOQUOTES);
  75         fprintf(f, " (%zu)", value_len);
  76         if ((print_flags & PRINT_XATTR_STATFMT) &&
  77             (strcmp(name, "system.data") == 0))
  78                 value_len = 0;
  79         if (value_len != 0 &&
  80             (!(print_flags & PRINT_XATTR_STATFMT) || (value_len < 40))) {
  81                 fprintf(f, " = ");
  82                 print_xattr_string(f, value, value_len, print_flags);
  83         }
  84         fputc('\n', f);
  85 }
  86
  87 static void print_fidstr(FILE *f, void *name, void *value,
  88                          ext2_ino_t inode_num, size_t value_len)
  89 {
  90         struct filter_fid_old *ff = value;
  91         int stripe;
  92
  93         /* Since Lustre 2.4 only the parent FID is stored in filter_fid,
  94          * and the self fid is stored in the LMA and is printed below. */
  95         if (value_len < sizeof(ff->ff_parent)) {
  96                 fprintf(stderr, "%s: error: filter_fid for inode %u smaller "
  97                         "than expected (%lu bytes).\n",
  98                         debug_prog_name, inode_num, value_len);
  99                 return;
 100         }
 101         fid_le_to_cpu(&ff->ff_parent, &ff->ff_parent);
 102         stripe = fid_ver(&ff->ff_parent); /* stripe index is stored in f_ver */
 103         ff->ff_parent.f_ver = 0;
 104
 105         fprintf(f, "  fid: ");
 106         /* Old larger filter_fid should only ever be used with seq = 0.
 107          * FID-on-OST should use LMA for FID_SEQ_NORMAL OST objects. */
 108         if (value_len == sizeof(*ff))
 109                 fprintf(f, "objid=%llu seq=%llu ",
 110                         ext2fs_le64_to_cpu(ff->ff_objid),
 111                         ext2fs_le64_to_cpu(ff->ff_seq));
 112
 113         fprintf(f, "parent="DFID" stripe=%u", PFID(&ff->ff_parent), stripe);
 114         if (value_len > sizeof(*ff)) {
 115                 struct filter_fid *ff_new = value;
 116
 117                 fprintf(f, " stripe_size=%u stripe_count=%u",
 118                         ext2fs_le32_to_cpu(ff_new->ff_stripe_size),
 119                         ext2fs_le32_to_cpu(ff_new->ff_stripe_count));
 120                 if (ff_new->ff_pfl_id != 0)
 121                         fprintf(f, " component_id=%u component_start=%llu "
 122                                 "component_end=%llu",
 123                                 ext2fs_le32_to_cpu(ff_new->ff_pfl_id),
 124                                 ext2fs_le64_to_cpu(ff_new->ff_pfl_start),
 125                                 ext2fs_le64_to_cpu(ff_new->ff_pfl_end));
 126         }
 127         fprintf(f, "\n");
 128 }
 129
 130 static void print_lmastr(FILE *f, void *name, void *value,
 131                          ext2_ino_t inode_num, size_t value_len)
 132 {
 133         struct lustre_mdt_attrs *lma = value;
 134         struct lustre_ost_attrs *loa = value;
 135
 136         if (value_len < offsetof(typeof(*lma), lma_self_fid) +
 137                         sizeof(lma->lma_self_fid)) {
 138                 fprintf(stderr, "%s: error: LMA for inode %u smaller than "
 139                         "expected (%lu bytes).\n",
 140                         debug_prog_name, inode_num, value_len);
 141                 return;
 142         }
 143         fid_le_to_cpu(&lma->lma_self_fid, &lma->lma_self_fid);
 144         fprintf(f, "  lma: fid="DFID" compat=%x incompat=%x\n",
 145                 PFID(&lma->lma_self_fid), ext2fs_le32_to_cpu(lma->lma_compat),
 146                 ext2fs_le32_to_cpu(lma->lma_incompat));
 147         if (value_len >= offsetof(typeof(*loa), loa_pfl_end) +
 148                   sizeof(loa->loa_pfl_end)) {
 149                 int idx;
 150                 int cnt;
 151
 152                 fid_le_to_cpu(&loa->loa_parent_fid, &loa->loa_parent_fid);
 153                 idx = loa->loa_parent_fid.f_ver & PFID_STRIPE_COUNT_MASK;
 154                 cnt = loa->loa_parent_fid.f_ver >> PFID_STRIPE_IDX_BITS;
 155                 loa->loa_parent_fid.f_ver = 0;
 156
 157                 fprintf(f, "  fid: parent="DFID" stripe=%u stripe_size=%u "
 158                         "stripe_count=%u", PFID(&loa->loa_parent_fid), idx,
 159                         ext2fs_le32_to_cpu(loa->loa_stripe_size), cnt);
 160                 if (loa->loa_pfl_id != 0)
 161                         fprintf(f, " component_id=%u component_start=%llu "
 162                                 "component_end=%llu",
 163                                 ext2fs_le32_to_cpu(loa->loa_pfl_id),
 164                                 ext2fs_le64_to_cpu(loa->loa_pfl_start),
 165                                 ext2fs_le64_to_cpu(loa->loa_pfl_end));
 166                 fprintf(f, "\n");
 167         }
 168 }
 169
 170 static int dump_attr(char *name, char *value, size_t value_len,
 171                      ext2_ino_t inode_num, void *data)
 172 {
 173         FILE *out = data;
 174
 175         fprintf(out, "  ");
 176         if (EXT2_HAS_INCOMPAT_FEATURE(current_fs->super,
 177                                       EXT4_FEATURE_INCOMPAT_EA_INODE) &&
 178                                       inode_num != 0) {
 179                 fprintf(out, "inode <%u> ", inode_num);
 180         }
 181         print_xattr(out, name, value, value_len, PRINT_XATTR_STATFMT);
 182         if (!strncmp(name, EXT2_ATTR_INDEX_TRUSTED_PREFIX LUSTRE_XATTR_OST_FID,
 183                      strlen(name)) ||
 184             !strncmp(name, EXT2_ATTR_INDEX_LUSTRE_PREFIX LUSTRE_XATTR_OST_FID,
 185                      strlen(name)))
 186                 print_fidstr(out, name, value, inode_num, value_len);
 187         if (!strncmp(name, EXT2_ATTR_INDEX_TRUSTED_PREFIX LUSTRE_XATTR_MDT_LMA,
 188                      strlen(name)) ||
 189             !strncmp(name, EXT2_ATTR_INDEX_LUSTRE_PREFIX LUSTRE_XATTR_MDT_LMA,
 190                      strlen(name)))
 191                 print_lmastr(out, name, value, inode_num, value_len);
 192         return 0;
 193 }
 194
 195 void dump_inode_attributes(FILE *out, ext2_ino_t ino)
 196 {
 197         struct ext2_xattr_handle *h;
 198         size_t sz;
 199         errcode_t err;
 200
 201         err = ext2fs_xattrs_open(current_fs, ino, &h);
 202         if (err)
 203                 return;
 204
 205         err = ext2fs_xattrs_read(h);
 206         if (err)
 207                 goto out;
 208
 209         err = ext2fs_xattrs_count(h, &sz);
 210         if (err || sz == 0)
 211                 goto out;
 212
 213         fprintf(out, "Extended attributes:\n");
 214         err = ext2fs_xattrs_iterate(h, dump_attr, out);
 215         if (err)
 216                 goto out;
 217
 218 out:
 219         err = ext2fs_xattrs_close(&h);
 220 }
 221
 222 void do_list_xattr(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)),
 223                    void *infop EXT2FS_ATTR((unused)))
 224 {
 225         ext2_ino_t ino;
 226
 227         if (argc != 2) {
 228                 printf("%s: Usage: %s <file>\n", argv[0],
 229                        argv[0]);
 230                 return;
 231         }
 232
 233         if (check_fs_open(argv[0]))
 234                 return;
 235
 236         ino = string_to_inode(argv[1]);
 237         if (!ino)
 238                 return;
 239
 240         dump_inode_attributes(stdout, ino);
 241 }
 242
 243 void do_get_xattr(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)),
 244                   void *infop EXT2FS_ATTR((unused)))
 245 {
 246         ext2_ino_t ino;
 247         struct ext2_xattr_handle *h;
 248         FILE *fp = NULL;
 249         char *buf = NULL;
 250         size_t buflen;
 251         int i;
 252         int print_flags = 0;
 253         unsigned int handle_flags = 0;
 254         errcode_t err;
 255
 256         reset_getopt();
 257         while ((i = getopt(argc, argv, "Cf:rxV")) != -1) {
 258                 switch (i) {
 259                 case 'f':
 260                         if (fp)
 261                                 fclose(fp);
 262                         fp = fopen(optarg, "w");
 263                         if (fp == NULL) {
 264                                 perror(optarg);
 265                                 return;
 266                         }
 267                         break;
 268                 case 'r':
 269                         handle_flags |= XATTR_HANDLE_FLAG_RAW;
 270                         break;
 271                 case 'x':
 272                         print_flags |= PRINT_XATTR_HEX;
 273                         break;
 274                 case 'V':
 275                         print_flags |= PRINT_XATTR_RAW|
 276                                 PRINT_XATTR_NOQUOTES;
 277                         break;
 278                 case 'C':
 279                         print_flags |= PRINT_XATTR_C;
 280                         break;
 281                 default:
 282                         goto usage;
 283                 }
 284         }
 285
 286         if (optind != argc - 2) {
 287         usage:
 288                 printf("%s: Usage: %s [-f outfile]|[-xVC] [-r] <file> <attr>\n",
 289                                argv[0], argv[0]);
 290
 291                 goto out2;
 292         }
 293
 294         if (check_fs_open(argv[0]))
 295                 goto out2;
 296
 297         ino = string_to_inode(argv[optind]);
 298         if (!ino)
 299                 goto out2;
 300
 301         err = ext2fs_xattrs_open(current_fs, ino, &h);
 302         if (err)
 303                 goto out2;
 304
 305         err = ext2fs_xattrs_flags(h, &handle_flags, NULL);
 306         if (err)
 307                 goto out;
 308
 309         err = ext2fs_xattrs_read(h);
 310         if (err)
 311                 goto out;
 312
 313         err = ext2fs_xattr_get(h, argv[optind + 1], (void **)&buf, &buflen);
 314         if (err)
 315                 goto out;
 316
 317         if (fp) {
 318                 fwrite(buf, buflen, 1, fp);
 319         } else {
 320                 if (print_flags & PRINT_XATTR_RAW) {
 321                         if (print_flags & (PRINT_XATTR_HEX|PRINT_XATTR_C))
 322                                 print_flags &= ~PRINT_XATTR_RAW;
 323                         print_xattr_string(stdout, buf, buflen, print_flags);
 324                 } else {
 325                         print_xattr(stdout, argv[optind + 1],
 326                                     buf, buflen, print_flags);
 327                 }
 328                 printf("\n");
 329         }
 330
 331         ext2fs_free_mem(&buf);
 332 out:
 333         ext2fs_xattrs_close(&h);
 334         if (err)
 335                 com_err(argv[0], err, "while getting extended attribute");
 336 out2:
 337         if (fp)
 338                 fclose(fp);
 339 }
 340
 341 void do_set_xattr(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)),
 342                   void *infop EXT2FS_ATTR((unused)))
 343 {
 344         ext2_ino_t ino;
 345         struct ext2_xattr_handle *h;
 346         FILE *fp = NULL;
 347         char *buf = NULL;
 348         size_t buflen;
 349         unsigned int handle_flags = 0;
 350         int i;
 351         errcode_t err;
 352
 353         reset_getopt();
 354         while ((i = getopt(argc, argv, "f:r")) != -1) {
 355                 switch (i) {
 356                 case 'f':
 357                         if (fp)
 358                                 fclose(fp);
 359                         fp = fopen(optarg, "r");
 360                         if (fp == NULL) {
 361                                 perror(optarg);
 362                                 return;
 363                         }
 364                         break;
 365                 case 'r':
 366                         handle_flags |= XATTR_HANDLE_FLAG_RAW;
 367                         break;
 368                 default:
 369                         goto print_usage;
 370                 }
 371         }
 372
 373         if (!(fp && optind == argc - 2) && !(!fp && optind == argc - 3)) {
 374         print_usage:
 375                 printf("Usage:\t%s [-r] <file> <attr> <value>\n", argv[0]);
 376                 printf("\t%s -f <value_file> [-r] <file> <attr>\n", argv[0]);
 377                 goto out2;
 378         }
 379
 380         if (check_fs_open(argv[0]))
 381                 goto out2;
 382         if (check_fs_read_write(argv[0]))
 383                 goto out2;
 384         if (check_fs_bitmaps(argv[0]))
 385                 goto out2;
 386
 387         ino = string_to_inode(argv[optind]);
 388         if (!ino)
 389                 goto out2;
 390
 391         err = ext2fs_xattrs_open(current_fs, ino, &h);
 392         if (err)
 393                 goto out2;
 394
 395         err = ext2fs_xattrs_flags(h, &handle_flags, NULL);
 396         if (err)
 397                 goto out;
 398
 399         err = ext2fs_xattrs_read(h);
 400         if (err)
 401                 goto out;
 402
 403         if (fp) {
 404                 err = ext2fs_get_mem(current_fs->blocksize, &buf);
 405                 if (err)
 406                         goto out;
 407                 buflen = fread(buf, 1, current_fs->blocksize, fp);
 408         } else {
 409                 buf = argv[optind + 2];
 410                 buflen = parse_c_string(buf);
 411         }
 412
 413         err = ext2fs_xattr_set(h, argv[optind + 1], buf, buflen);
 414 out:
 415         ext2fs_xattrs_close(&h);
 416         if (err)
 417                 com_err(argv[0], err, "while setting extended attribute");
 418 out2:
 419         if (fp) {
 420                 fclose(fp);
 421                 ext2fs_free_mem(&buf);
 422         }
 423 }
 424
 425 void do_rm_xattr(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)),
 426                  void *infop EXT2FS_ATTR((unused)))
 427 {
 428         ext2_ino_t ino;
 429         struct ext2_xattr_handle *h;
 430         int i;
 431         errcode_t err;
 432
 433         if (argc < 3) {
 434                 printf("%s: Usage: %s <file> <attrs>...\n", argv[0], argv[0]);
 435                 return;
 436         }
 437
 438         if (check_fs_open(argv[0]))
 439                 return;
 440         if (check_fs_read_write(argv[0]))
 441                 return;
 442         if (check_fs_bitmaps(argv[0]))
 443                 return;
 444
 445         ino = string_to_inode(argv[1]);
 446         if (!ino)
 447                 return;
 448
 449         err = ext2fs_xattrs_open(current_fs, ino, &h);
 450         if (err)
 451                 return;
 452
 453         err = ext2fs_xattrs_read(h);
 454         if (err)
 455                 goto out;
 456
 457         for (i = 2; i < argc; i++) {
 458                 err = ext2fs_xattr_remove(h, argv[i]);
 459                 if (err)
 460                         goto out;
 461         }
 462 out:
 463         ext2fs_xattrs_close(&h);
 464         if (err)
 465                 com_err(argv[0], err, "while removing extended attribute");
 466 }
 467
 468 /*
 469  * Return non-zero if the string has a minimal number of non-printable
 470  * characters.
 471  */
 472 static int is_mostly_printable(const char *cp, int len)
 473 {
 474         int     np = 0;
 475
 476         if (len < 0)
 477                 len = strlen(cp);
 478
 479         while (len--) {
 480                 if (!isprint(*cp++)) {
 481                         np++;
 482                         if (np > 3)
 483                                 return 0;
 484                 }
 485         }
 486         return 1;
 487 }
 488
 489 static void safe_print(FILE *f, const char *cp, int len)
 490 {
 491         unsigned char   ch;
 492
 493         if (len < 0)
 494                 len = strlen(cp);
 495
 496         while (len--) {
 497                 ch = *cp++;
 498                 if (ch > 128) {
 499                         fputs("M-", f);
 500                         ch -= 128;
 501                 }
 502                 if ((ch < 32) || (ch == 0x7f)) {
 503                         fputc('^', f);
 504                         ch ^= 0x40; /* ^@, ^A, ^B; ^? for DEL */
 505                 }
 506                 fputc(ch, f);
 507         }
 508 }
 509
 510 static void dump_xattr_raw_entries(FILE *f, unsigned char *buf,
 511                                    unsigned int start, unsigned int len,
 512                                    unsigned value_start)
 513 {
 514         struct ext2_ext_attr_entry ent;
 515         unsigned int off = start;
 516         unsigned int vstart;
 517
 518         while (off < len) {
 519                 if ((*(__u16 *) (buf + off)) == 0) {
 520                         fprintf(f, "last entry found at offset %u (%04o)\n",
 521                                 off, off);
 522                         break;
 523                 }
 524                 if ((off + sizeof(struct ext2_ext_attr_entry)) >= len) {
 525                         fprintf(f, "xattr buffer overrun at %u (len = %u)\n",
 526                                 off, len);
 527                         break;
 528                 }
 529 #if WORDS_BIGENDIAN
 530                 ext2fs_swap_ext_attr_entry(&ent,
 531                         (struct ext2_ext_attr_entry *) (buf + off));
 532 #else
 533                 ent = *((struct ext2_ext_attr_entry *) (buf + off));
 534 #endif
 535                 fprintf(f, "offset = %d (%04o), name_len = %u, "
 536                         "name_index = %u\n",
 537                         off, off, ent.e_name_len, ent.e_name_index);
 538                 vstart = value_start + ent.e_value_offs;
 539                 fprintf(f, "value_offset = %d (%04o), value_inum = %u, "
 540                         "value_size = %u\n", ent.e_value_offs,
 541                         vstart, ent.e_value_inum, ent.e_value_size);
 542                 off += sizeof(struct ext2_ext_attr_entry);
 543                 fprintf(f, "name = ");
 544                 if ((off + ent.e_name_len) >= len)
 545                         fprintf(f, "<runs off end>");
 546                 else
 547                         safe_print(f, (char *)(buf + off), ent.e_name_len);
 548                 fputc('\n', f);
 549                 if (ent.e_value_size == 0)
 550                         goto skip_value;
 551                 fprintf(f, "value = ");
 552                 if (ent.e_value_inum)
 553                         fprintf(f, "<ino %u>", ent.e_value_inum);
 554                 else if (ent.e_value_offs >= len ||
 555                          (vstart + ent.e_value_size) > len)
 556                         fprintf(f, "<runs off end>");
 557                 else if (is_mostly_printable((char *)(buf + vstart),
 558                                         ent.e_value_size))
 559                         safe_print(f, (char *)(buf + vstart),
 560                                    ent.e_value_size);
 561                 else {
 562                         fprintf(f, "<hexdump>\n");
 563                         do_byte_hexdump(f, (unsigned char *)(buf + vstart),
 564                                         ent.e_value_size);
 565                 }
 566                 fputc('\n', f);
 567         skip_value:
 568                 fputc('\n', f);
 569                 off += (ent.e_name_len + 3) & ~3;
 570         }
 571 }
 572
 573 void raw_inode_xattr_dump(FILE *f, unsigned char *buf, unsigned int len)
 574 {
 575         __u32 magic = ext2fs_le32_to_cpu(*((__le32 *) buf));
 576
 577         fprintf(f, "magic = %08x, length = %u, value_start =4 \n\n",
 578                 magic, len);
 579         if (magic == EXT2_EXT_ATTR_MAGIC)
 580                 dump_xattr_raw_entries(f, buf, 4, len, 4);
 581 }
 582
 583 void block_xattr_dump(FILE *f, unsigned char *buf, unsigned int len)
 584 {
 585         struct ext2_ext_attr_header header;
 586
 587 #ifdef WORDS_BIGENDIAN
 588         ext2fs_swap_ext_attr_header(&header,
 589                                     (struct ext2_ext_attr_header *) buf);
 590 #else
 591         header = *((struct ext2_ext_attr_header *) buf);
 592 #endif
 593         fprintf(f, "magic = %08x, length = %u\n", header.h_magic, len);
 594         if (header.h_magic != EXT2_EXT_ATTR_MAGIC)
 595                 return;
 596         fprintf(f, "refcount = %u, blocks = %u\n", header.h_refcount,
 597                 header.h_blocks);
 598         fprintf(f, "hash = %08x, checksum = %08x\n", header.h_hash,
 599                 header.h_checksum);
 600         fprintf(f, "reserved: %08x %08x %08x\n\n", header.h_reserved[0],
 601                 header.h_reserved[1], header.h_reserved[2]);
 602
 603         dump_xattr_raw_entries(f, buf,
 604                                sizeof(struct ext2_ext_attr_header), len, 0);
 605 }