e2fsck/ehandler.c

   1 /*
   2  * ehandler.c --- handle bad block errors which come up during the
   3  *      course of an e2fsck session.
   4  *
   5  * Copyright (C) 1994 Theodore Ts'o.  This file may be redistributed
   6  * under the terms of the GNU Public License.
   7  */
   8
   9 #include <stdlib.h>
  10 #include <unistd.h>
  11 #include <string.h>
  12 #include <ctype.h>
  13 #include <termios.h>
  14
  15 #include "e2fsck.h"
  16
  17 #include <sys/time.h>
  18 #include <sys/resource.h>
  19
  20 static const char *operation;
  21
  22 static errcode_t e2fsck_handle_read_error(io_channel channel,
  23                                           unsigned long block,
  24                                           int count,
  25                                           void *data,
  26                                           size_t size EXT2FS_ATTR((unused)),
  27                                           int actual EXT2FS_ATTR((unused)),
  28                                           errcode_t error)
  29 {
  30         int     i;
  31         char    *p;
  32         ext2_filsys fs = (ext2_filsys) channel->app_data;
  33         e2fsck_t ctx;
  34
  35         ctx = (e2fsck_t) fs->priv_data;
  36         if (ctx->flags & E2F_FLAG_EXITING)
  37                 return 0;
  38         /*
  39          * If more than one block was read, try reading each block
  40          * separately.  We could use the actual bytes read to figure
  41          * out where to start, but we don't bother.
  42          */
  43         if (count > 1) {
  44                 p = (char *) data;
  45                 for (i=0; i < count; i++, p += channel->block_size, block++) {
  46                         error = io_channel_read_blk64(channel, block,
  47                                                     1, p);
  48                         if (error)
  49                                 return error;
  50                 }
  51                 return 0;
  52         }
  53         if (operation)
  54                 printf(_("Error reading block %lu (%s) while %s.  "), block,
  55                        error_message(error), operation);
  56         else
  57                 printf(_("Error reading block %lu (%s).  "), block,
  58                        error_message(error));
  59         preenhalt(ctx);
  60         if (ask(ctx, _("Ignore error"), 1)) {
  61                 if (ask(ctx, _("Force rewrite"), 1))
  62                         io_channel_write_blk64(channel, block, 1, data);
  63                 return 0;
  64         }
  65
  66         return error;
  67 }
  68
  69 static errcode_t e2fsck_handle_write_error(io_channel channel,
  70                                             unsigned long block,
  71                                             int count,
  72                                             const void *data,
  73                                             size_t size EXT2FS_ATTR((unused)),
  74                                             int actual EXT2FS_ATTR((unused)),
  75                                             errcode_t error)
  76 {
  77         int             i;
  78         const char      *p;
  79         ext2_filsys fs = (ext2_filsys) channel->app_data;
  80         e2fsck_t ctx;
  81
  82         ctx = (e2fsck_t) fs->priv_data;
  83         if (ctx->flags & E2F_FLAG_EXITING)
  84                 return 0;
  85
  86         /*
  87          * If more than one block was written, try writing each block
  88          * separately.  We could use the actual bytes read to figure
  89          * out where to start, but we don't bother.
  90          */
  91         if (count > 1) {
  92                 p = (const char *) data;
  93                 for (i=0; i < count; i++, p += channel->block_size, block++) {
  94                         error = io_channel_write_blk64(channel, block,
  95                                                      1, p);
  96                         if (error)
  97                                 return error;
  98                 }
  99                 return 0;
 100         }
 101
 102         if (operation)
 103                 printf(_("Error writing block %lu (%s) while %s.  "), block,
 104                        error_message(error), operation);
 105         else
 106                 printf(_("Error writing block %lu (%s).  "), block,
 107                        error_message(error));
 108         preenhalt(ctx);
 109         if (ask(ctx, _("Ignore error"), 1))
 110                 return 0;
 111
 112         return error;
 113 }
 114
 115 const char *ehandler_operation(const char *op)
 116 {
 117         const char *ret = operation;
 118
 119         operation = op;
 120         return ret;
 121 }
 122
 123 void ehandler_init(io_channel channel)
 124 {
 125         channel->read_error = e2fsck_handle_read_error;
 126         channel->write_error = e2fsck_handle_write_error;
 127 }