e2fsck/util.c

   1 /*
   2  * util.c --- miscellaneous utilities
   3  *
   4  * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o.
   5  *
   6  * %Begin-Header%
   7  * This file may be redistributed under the terms of the GNU Public
   8  * License.
   9  * %End-Header%
  10  */
  11
  12 #include <stdlib.h>
  13 #include <unistd.h>
  14 #include <string.h>
  15 #include <ctype.h>
  16
  17 #ifdef HAVE_CONIO_H
  18 #undef HAVE_TERMIOS_H
  19 #include <conio.h>
  20 #define read_a_char()   getch()
  21 #else
  22 #ifdef HAVE_TERMIOS_H
  23 #include <termios.h>
  24 #endif
  25 #include <stdio.h>
  26 #endif
  27
  28 #ifdef HAVE_MALLOC_H
  29 #include <malloc.h>
  30 #endif
  31
  32 #ifdef HAVE_ERRNO_H
  33 #include <errno.h>
  34 #endif
  35
  36 #include "e2fsck.h"
  37
  38 extern e2fsck_t e2fsck_global_ctx;   /* Try your very best not to use this! */
  39
  40 #include <sys/time.h>
  41 #include <sys/resource.h>
  42
  43 void fatal_error(e2fsck_t ctx, const char *msg)
  44 {
  45         if (msg)
  46                 fprintf (stderr, "e2fsck: %s\n", msg);
  47         if (ctx->fs && ctx->fs->io) {
  48                 if (ctx->fs->io->magic == EXT2_ET_MAGIC_IO_CHANNEL)
  49                         io_channel_flush(ctx->fs->io);
  50                 else
  51                         fprintf(stderr, "e2fsck: io manager magic bad!\n");
  52         }
  53         ctx->flags |= E2F_FLAG_ABORT;
  54         if (ctx->flags & E2F_FLAG_SETJMP_OK)
  55                 longjmp(ctx->abort_loc, 1);
  56         exit(FSCK_ERROR);
  57 }
  58
  59 void *e2fsck_allocate_memory(e2fsck_t ctx, unsigned int size,
  60                              const char *description)
  61 {
  62         void *ret;
  63         char buf[256];
  64
  65 #ifdef DEBUG_ALLOCATE_MEMORY
  66         printf("Allocating %d bytes for %s...\n", size, description);
  67 #endif
  68         ret = malloc(size);
  69         if (!ret) {
  70                 sprintf(buf, "Can't allocate %s\n", description);
  71                 fatal_error(ctx, buf);
  72         }
  73         memset(ret, 0, size);
  74         return ret;
  75 }
  76
  77 char *string_copy(e2fsck_t ctx EXT2FS_ATTR((unused)),
  78                   const char *str, int len)
  79 {
  80         char    *ret;
  81
  82         if (!str)
  83                 return NULL;
  84         if (!len)
  85                 len = strlen(str);
  86         ret = malloc(len+1);
  87         if (ret) {
  88                 strncpy(ret, str, len);
  89                 ret[len] = 0;
  90         }
  91         return ret;
  92 }
  93
  94 #ifndef HAVE_STRNLEN
  95 /*
  96  * Incredibly, libc5 doesn't appear to have strnlen.  So we have to
  97  * provide our own.
  98  */
  99 int e2fsck_strnlen(const char * s, int count)
 100 {
 101         const char *cp = s;
 102
 103         while (count-- && *cp)
 104                 cp++;
 105         return cp - s;
 106 }
 107 #endif
 108
 109 #ifndef HAVE_CONIO_H
 110 static int read_a_char(void)
 111 {
 112         char    c;
 113         int     r;
 114         int     fail = 0;
 115
 116         while(1) {
 117                 if (e2fsck_global_ctx &&
 118                     (e2fsck_global_ctx->flags & E2F_FLAG_CANCEL)) {
 119                         return 3;
 120                 }
 121                 r = read(0, &c, 1);
 122                 if (r == 1)
 123                         return c;
 124                 if (fail++ > 100)
 125                         break;
 126         }
 127         return EOF;
 128 }
 129 #endif
 130
 131 int ask_yn(const char * string, int def)
 132 {
 133         int             c;
 134         const char      *defstr;
 135         const char      *short_yes = _("yY");
 136         const char      *short_no = _("nN");
 137
 138 #ifdef HAVE_TERMIOS_H
 139         struct termios  termios, tmp;
 140
 141         tcgetattr (0, &termios);
 142         tmp = termios;
 143         tmp.c_lflag &= ~(ICANON | ECHO);
 144         tmp.c_cc[VMIN] = 1;
 145         tmp.c_cc[VTIME] = 0;
 146         tcsetattr (0, TCSANOW, &tmp);
 147 #endif
 148
 149         if (def == 1)
 150                 defstr = _(_("<y>"));
 151         else if (def == 0)
 152                 defstr = _(_("<n>"));
 153         else
 154                 defstr = _(" (y/n)");
 155         printf("%s%s? ", string, defstr);
 156         while (1) {
 157                 fflush (stdout);
 158                 if ((c = read_a_char()) == EOF)
 159                         break;
 160                 if (c == 3) {
 161 #ifdef HAVE_TERMIOS_H
 162                         tcsetattr (0, TCSANOW, &termios);
 163 #endif
 164                         if (e2fsck_global_ctx &&
 165                             e2fsck_global_ctx->flags & E2F_FLAG_SETJMP_OK) {
 166                                 puts("\n");
 167                                 longjmp(e2fsck_global_ctx->abort_loc, 1);
 168                         }
 169                         puts(_("cancelled!\n"));
 170                         return 0;
 171                 }
 172                 if (strchr(short_yes, (char) c)) {
 173                         def = 1;
 174                         break;
 175                 }
 176                 else if (strchr(short_no, (char) c)) {
 177                         def = 0;
 178                         break;
 179                 }
 180                 else if ((c == ' ' || c == '\n') && (def != -1))
 181                         break;
 182         }
 183         if (def)
 184                 puts(_("yes\n"));
 185         else
 186                 puts (_("no\n"));
 187 #ifdef HAVE_TERMIOS_H
 188         tcsetattr (0, TCSANOW, &termios);
 189 #endif
 190         return def;
 191 }
 192
 193 int ask (e2fsck_t ctx, const char * string, int def)
 194 {
 195         if (ctx->options & E2F_OPT_NO) {
 196                 printf (_("%s? no\n\n"), string);
 197                 return 0;
 198         }
 199         if (ctx->options & E2F_OPT_YES) {
 200                 printf (_("%s? yes\n\n"), string);
 201                 return 1;
 202         }
 203         if (ctx->options & E2F_OPT_PREEN) {
 204                 printf ("%s? %s\n\n", string, def ? _("yes") : _("no"));
 205                 return def;
 206         }
 207         return ask_yn(string, def);
 208 }
 209
 210 void e2fsck_read_bitmaps(e2fsck_t ctx)
 211 {
 212         ext2_filsys fs = ctx->fs;
 213         errcode_t       retval;
 214         const char      *old_op;
 215
 216         if (ctx->invalid_bitmaps) {
 217                 com_err(ctx->program_name, 0,
 218                     _("e2fsck_read_bitmaps: illegal bitmap block(s) for %s"),
 219                         ctx->device_name);
 220                 fatal_error(ctx, 0);
 221         }
 222
 223         old_op = ehandler_operation(_("reading inode and block bitmaps"));
 224         retval = ext2fs_read_bitmaps(fs);
 225         ehandler_operation(old_op);
 226         if (retval) {
 227                 com_err(ctx->program_name, retval,
 228                         _("while retrying to read bitmaps for %s"),
 229                         ctx->device_name);
 230                 fatal_error(ctx, 0);
 231         }
 232 }
 233
 234 void e2fsck_write_bitmaps(e2fsck_t ctx)
 235 {
 236         ext2_filsys fs = ctx->fs;
 237         errcode_t       retval;
 238         const char      *old_op;
 239
 240         old_op = ehandler_operation(_("writing block and inode bitmaps"));
 241         retval = ext2fs_write_bitmaps(fs);
 242         ehandler_operation(old_op);
 243         if (retval) {
 244                 com_err(ctx->program_name, retval,
 245                         _("while rewriting block and inode bitmaps for %s"),
 246                         ctx->device_name);
 247                 fatal_error(ctx, 0);
 248         }
 249 }
 250
 251 void preenhalt(e2fsck_t ctx)
 252 {
 253         ext2_filsys fs = ctx->fs;
 254
 255         if (!(ctx->options & E2F_OPT_PREEN))
 256                 return;
 257         fprintf(stderr, _("\n\n%s: UNEXPECTED INCONSISTENCY; "
 258                 "RUN fsck MANUALLY.\n\t(i.e., without -a or -p options)\n"),
 259                ctx->device_name);
 260         if (fs != NULL) {
 261                 fs->super->s_state |= EXT2_ERROR_FS;
 262                 ext2fs_mark_super_dirty(fs);
 263                 ext2fs_close(fs);
 264         }
 265         exit(FSCK_UNCORRECTED);
 266 }
 267
 268 #ifdef RESOURCE_TRACK
 269 void init_resource_track(struct resource_track *track, io_channel channel)
 270 {
 271 #ifdef HAVE_GETRUSAGE
 272         struct rusage r;
 273 #endif
 274         io_stats io_start = 0;
 275
 276         track->brk_start = sbrk(0);
 277         gettimeofday(&track->time_start, 0);
 278 #ifdef HAVE_GETRUSAGE
 279 #ifdef sun
 280         memset(&r, 0, sizeof(struct rusage));
 281 #endif
 282         getrusage(RUSAGE_SELF, &r);
 283         track->user_start = r.ru_utime;
 284         track->system_start = r.ru_stime;
 285 #else
 286         track->user_start.tv_sec = track->user_start.tv_usec = 0;
 287         track->system_start.tv_sec = track->system_start.tv_usec = 0;
 288 #endif
 289         track->bytes_read = 0;
 290         track->bytes_written = 0;
 291         if (channel && channel->manager && channel->manager->get_stats)
 292                 channel->manager->get_stats(channel, &io_start);
 293         if (io_start) {
 294                 track->bytes_read = io_start->bytes_read;
 295                 track->bytes_written = io_start->bytes_written;
 296         }
 297 }
 298
 299 #ifdef __GNUC__
 300 #define _INLINE_ __inline__
 301 #else
 302 #define _INLINE_
 303 #endif
 304
 305 static _INLINE_ float timeval_subtract(struct timeval *tv1,
 306                                        struct timeval *tv2)
 307 {
 308         return ((tv1->tv_sec - tv2->tv_sec) +
 309                 ((float) (tv1->tv_usec - tv2->tv_usec)) / 1000000);
 310 }
 311
 312 void print_resource_track(const char *desc, struct resource_track *track,
 313                           io_channel channel)
 314 {
 315 #ifdef HAVE_GETRUSAGE
 316         struct rusage r;
 317 #endif
 318 #ifdef HAVE_MALLINFO
 319         struct mallinfo malloc_info;
 320 #endif
 321         struct timeval time_end;
 322
 323         gettimeofday(&time_end, 0);
 324
 325         if (desc)
 326                 printf("%s: ", desc);
 327
 328 #ifdef HAVE_MALLINFO
 329 #define kbytes(x)       (((x) + 1023) / 1024)
 330
 331         malloc_info = mallinfo();
 332         printf(_("Memory used: %dk/%dk (%dk/%dk), "),
 333                kbytes(malloc_info.arena), kbytes(malloc_info.hblkhd),
 334                kbytes(malloc_info.uordblks), kbytes(malloc_info.fordblks));
 335 #else
 336         printf(_("Memory used: %d, "),
 337                (int) (((char *) sbrk(0)) - ((char *) track->brk_start)));
 338 #endif
 339 #ifdef HAVE_GETRUSAGE
 340         getrusage(RUSAGE_SELF, &r);
 341
 342         printf(_("time: %5.2f/%5.2f/%5.2f\n"),
 343                timeval_subtract(&time_end, &track->time_start),
 344                timeval_subtract(&r.ru_utime, &track->user_start),
 345                timeval_subtract(&r.ru_stime, &track->system_start));
 346 #else
 347         printf(_("elapsed time: %6.3f\n"),
 348                timeval_subtract(&time_end, &track->time_start));
 349 #endif
 350 #define mbytes(x)       (((x) + 1048575) / 1048576)
 351         if (channel && channel->manager && channel->manager->get_stats) {
 352                 io_stats delta = 0;
 353                 unsigned long long bytes_read = 0;
 354                 unsigned long long bytes_written = 0;
 355
 356                 if (desc)
 357                         printf("%s: ", desc);
 358
 359                 channel->manager->get_stats(channel, &delta);
 360                 if (delta) {
 361                         bytes_read = delta->bytes_read - track->bytes_read;
 362                         bytes_written = delta->bytes_written -
 363                                 track->bytes_written;
 364                 }
 365                 printf("I/O read: %lluMB, write: %lluMB, rate: %.2fMB/s\n",
 366                        mbytes(bytes_read), mbytes(bytes_written),
 367                        (double)mbytes(bytes_read + bytes_written) /
 368                        timeval_subtract(&time_end, &track->time_start));
 369         }
 370 }
 371 #endif /* RESOURCE_TRACK */
 372
 373 void e2fsck_read_inode(e2fsck_t ctx, unsigned long ino,
 374                               struct ext2_inode * inode, const char *proc)
 375 {
 376         int retval;
 377
 378         retval = ext2fs_read_inode(ctx->fs, ino, inode);
 379         if (retval) {
 380                 com_err("ext2fs_read_inode", retval,
 381                         _("while reading inode %ld in %s"), ino, proc);
 382                 fatal_error(ctx, 0);
 383         }
 384 }
 385
 386 void e2fsck_read_inode_full(e2fsck_t ctx, unsigned long ino,
 387                             struct ext2_inode *inode, int bufsize,
 388                             const char *proc)
 389 {
 390         int retval;
 391
 392         retval = ext2fs_read_inode_full(ctx->fs, ino, inode, bufsize);
 393         if (retval) {
 394                 com_err("ext2fs_read_inode_full", retval,
 395                         _("while reading inode %ld in %s"), ino, proc);
 396                 fatal_error(ctx, 0);
 397         }
 398 }
 399
 400 extern void e2fsck_write_inode_full(e2fsck_t ctx, unsigned long ino,
 401                                struct ext2_inode * inode, int bufsize,
 402                                const char *proc)
 403 {
 404         int retval;
 405
 406         retval = ext2fs_write_inode_full(ctx->fs, ino, inode, bufsize);
 407         if (retval) {
 408                 com_err("ext2fs_write_inode", retval,
 409                         _("while writing inode %ld in %s"), ino, proc);
 410                 fatal_error(ctx, 0);
 411         }
 412 }
 413
 414 extern void e2fsck_write_inode(e2fsck_t ctx, unsigned long ino,
 415                                struct ext2_inode * inode, const char *proc)
 416 {
 417         int retval;
 418
 419         retval = ext2fs_write_inode(ctx->fs, ino, inode);
 420         if (retval) {
 421                 com_err("ext2fs_write_inode", retval,
 422                         _("while writing inode %ld in %s"), ino, proc);
 423                 fatal_error(ctx, 0);
 424         }
 425 }
 426
 427 #ifdef MTRACE
 428 void mtrace_print(char *mesg)
 429 {
 430         FILE    *malloc_get_mallstream();
 431         FILE    *f = malloc_get_mallstream();
 432
 433         if (f)
 434                 fprintf(f, "============= %s\n", mesg);
 435 }
 436 #endif
 437
 438 blk_t get_backup_sb(e2fsck_t ctx, ext2_filsys fs, const char *name,
 439                    io_manager manager)
 440 {
 441         struct ext2_super_block *sb;
 442         io_channel              io = NULL;
 443         void                    *buf = NULL;
 444         int                     blocksize;
 445         blk_t                   superblock, ret_sb = 8193;
 446
 447         if (fs && fs->super) {
 448                 ret_sb = (fs->super->s_blocks_per_group +
 449                           fs->super->s_first_data_block);
 450                 if (ctx) {
 451                         ctx->superblock = ret_sb;
 452                         ctx->blocksize = fs->blocksize;
 453                 }
 454                 return ret_sb;
 455         }
 456
 457         if (ctx) {
 458                 if (ctx->blocksize) {
 459                         ret_sb = ctx->blocksize * 8;
 460                         if (ctx->blocksize == 1024)
 461                                 ret_sb++;
 462                         ctx->superblock = ret_sb;
 463                         return ret_sb;
 464                 }
 465                 ctx->superblock = ret_sb;
 466                 ctx->blocksize = 1024;
 467         }
 468
 469         if (!name || !manager)
 470                 goto cleanup;
 471
 472         if (manager->open(name, 0, &io) != 0)
 473                 goto cleanup;
 474
 475         if (ext2fs_get_mem(SUPERBLOCK_SIZE, &buf))
 476                 goto cleanup;
 477         sb = (struct ext2_super_block *) buf;
 478
 479         for (blocksize = EXT2_MIN_BLOCK_SIZE;
 480              blocksize <= EXT2_MAX_BLOCK_SIZE ; blocksize *= 2) {
 481                 superblock = blocksize*8;
 482                 if (blocksize == 1024)
 483                         superblock++;
 484                 io_channel_set_blksize(io, blocksize);
 485                 if (io_channel_read_blk(io, superblock,
 486                                         -SUPERBLOCK_SIZE, buf))
 487                         continue;
 488 #ifdef WORDS_BIGENDIAN
 489                 if (sb->s_magic == ext2fs_swab16(EXT2_SUPER_MAGIC))
 490                         ext2fs_swap_super(sb);
 491 #endif
 492                 if ((sb->s_magic == EXT2_SUPER_MAGIC) &&
 493                     (EXT2_BLOCK_SIZE(sb) == blocksize)) {
 494                         ret_sb = superblock;
 495                         if (ctx) {
 496                                 ctx->superblock = superblock;
 497                                 ctx->blocksize = blocksize;
 498                         }
 499                         break;
 500                 }
 501         }
 502
 503 cleanup:
 504         if (io)
 505                 io_channel_close(io);
 506         if (buf)
 507                 ext2fs_free_mem(&buf);
 508         return (ret_sb);
 509 }
 510
 511 /*
 512  * Given a mode, return the ext2 file type
 513  */
 514 int ext2_file_type(unsigned int mode)
 515 {
 516         if (LINUX_S_ISREG(mode))
 517                 return EXT2_FT_REG_FILE;
 518
 519         if (LINUX_S_ISDIR(mode))
 520                 return EXT2_FT_DIR;
 521
 522         if (LINUX_S_ISCHR(mode))
 523                 return EXT2_FT_CHRDEV;
 524
 525         if (LINUX_S_ISBLK(mode))
 526                 return EXT2_FT_BLKDEV;
 527
 528         if (LINUX_S_ISLNK(mode))
 529                 return EXT2_FT_SYMLINK;
 530
 531         if (LINUX_S_ISFIFO(mode))
 532                 return EXT2_FT_FIFO;
 533
 534         if (LINUX_S_ISSOCK(mode))
 535                 return EXT2_FT_SOCK;
 536
 537         return 0;
 538 }
 539
 540 #define STRIDE_LENGTH 8
 541 /*
 542  * Helper function which zeros out _num_ blocks starting at _blk_.  In
 543  * case of an error, the details of the error is returned via _ret_blk_
 544  * and _ret_count_ if they are non-NULL pointers.  Returns 0 on
 545  * success, and an error code on an error.
 546  *
 547  * As a special case, if the first argument is NULL, then it will
 548  * attempt to free the static zeroizing buffer.  (This is to keep
 549  * programs that check for memory leaks happy.)
 550  */
 551 errcode_t e2fsck_zero_blocks(ext2_filsys fs, blk_t blk, int num,
 552                              blk_t *ret_blk, int *ret_count)
 553 {
 554         int             j, count, next_update, next_update_incr;
 555         static char     *buf;
 556         errcode_t       retval;
 557
 558         /* If fs is null, clean up the static buffer and return */
 559         if (!fs) {
 560                 if (buf) {
 561                         free(buf);
 562                         buf = 0;
 563                 }
 564                 return 0;
 565         }
 566         /* Allocate the zeroizing buffer if necessary */
 567         if (!buf) {
 568                 buf = malloc(fs->blocksize * STRIDE_LENGTH);
 569                 if (!buf) {
 570                         com_err("malloc", ENOMEM,
 571                                 _("while allocating zeroizing buffer"));
 572                         exit(1);
 573                 }
 574                 memset(buf, 0, fs->blocksize * STRIDE_LENGTH);
 575         }
 576         /* OK, do the write loop */
 577         next_update = 0;
 578         next_update_incr = num / 100;
 579         if (next_update_incr < 1)
 580                 next_update_incr = 1;
 581         for (j = 0; j < num; j += STRIDE_LENGTH, blk += STRIDE_LENGTH) {
 582                 count = num - j;
 583                 if (count > STRIDE_LENGTH)
 584                         count = STRIDE_LENGTH;
 585                 retval = io_channel_write_blk(fs->io, blk, count, buf);
 586                 if (retval) {
 587                         if (ret_count)
 588                                 *ret_count = count;
 589                         if (ret_blk)
 590                                 *ret_blk = blk;
 591                         return retval;
 592                 }
 593         }
 594         return 0;
 595 }