check.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <stdarg.h>
   4 #include <string.h>
   5 #include <ctype.h>
   6 #include "omfs.h"
   7 #include "dirscan.h"
   8 #include "check.h"
   9 #include "crc.h"
  10 #include "fix.h"
  11 #include "bits.h"
  12 #include "io.h"
  13
  14 /*
  15  * TODO:
  16  *
  17  * - check hash table index
  18  * - clear extents from free bitmap and make sure free bitmap is null
  19  * - sanity check block size, sys block size, mirrors, etc
  20  * - check that extent count is valid
  21  * - check that terminator matches
  22  * - make sure file sizes match up
  23  */
  24
  25 int check_crc(u8 *blk)
  26 {
  27         u16 crc;
  28         size_t hdr_size = sizeof(struct omfs_header);
  29         struct omfs_inode *oi;
  30
  31         oi = (struct omfs_inode *) blk;
  32
  33         crc = crc_ccitt_msb(0, blk + hdr_size,
  34                 swap_be32(oi->i_head.h_body_size));
  35
  36         return (crc == swap_be16(oi->i_head.h_crc));
  37 }
  38
  39 int check_header(u8 *blk)
  40 {
  41         int i;
  42         int xor;
  43         struct omfs_inode *oi;
  44
  45         oi = (struct omfs_inode *) blk;
  46
  47         xor = blk[0];
  48         for (i = 1; i < OMFS_XOR_COUNT; i++)
  49                 xor ^= blk[i];
  50
  51         return (xor == oi->i_head.h_check_xor);
  52 }
  53
  54 int check_sanity(check_context_t *ctx)
  55 {
  56         omfs_inode_t *inode = ctx->current_inode;
  57         if (swap_be32(inode->i_head.h_body_size) >
  58             swap_be32(ctx->omfs_info->super->s_sys_blocksize))
  59                 return 0;
  60
  61         // check device size here too.
  62         return 1;
  63 }
  64
  65 int check_bitmap(check_context_t *ctx)
  66 {
  67         int i;
  68         int is_ok = 1;
  69         int bsize, first_blk;
  70         omfs_super_t *super = ctx->omfs_info->super;
  71         omfs_root_t *root = ctx->omfs_info->root;
  72
  73         if (!ctx->bitmap)
  74                 return 0;
  75
  76         bsize = (swap_be64(super->s_num_blocks) + 7) / 8;
  77         first_blk = swap_be64(root->r_bitmap) + (bsize +
  78                 swap_be32(super->s_blocksize)-1) /
  79                 swap_be32(super->s_blocksize);
  80
  81         for (i=0; i < first_blk; i++)
  82                 set_bit(ctx->visited, i);
  83
  84         for (i=0; i < bsize; i++)
  85         {
  86                 if (ctx->bitmap[i] != ctx->visited[i])
  87                 {
  88                         is_ok = 0;
  89                         if (!ctx->config->is_quiet)
  90                         {
  91                                 printf("Wrong bitmap byte at %d (%02x,%02x)\n",
  92                                         i, ctx->bitmap[i], ctx->visited[i]);
  93                         }
  94                 }
  95         }
  96         if (!is_ok)
  97         {
  98                 fix_problem(E_BITMAP, ctx);
  99         }
 100         return is_ok;
 101 }
 102
 103 void visit_extents(check_context_t *ctx)
 104 {
 105         struct omfs_extent *oe;
 106         struct omfs_extent_entry *entry;
 107         u64 last, next;
 108         int extent_count, i;
 109         u8 *buf;
 110
 111         next = ctx->block;
 112         buf = omfs_get_block(ctx->omfs_info, next);
 113         if (!buf)
 114                 return;
 115
 116         oe = (struct omfs_extent *) &buf[OMFS_EXTENT_START];
 117
 118         for(;;)
 119         {
 120                 extent_count = swap_be32(oe->e_extent_count);
 121                 last = next;
 122                 next = swap_be64(oe->e_next);
 123                 entry = &oe->e_entry;
 124
 125                 // ignore last entry as it is the terminator
 126                 for (; extent_count > 1; extent_count--)
 127                 {
 128                         u64 start = swap_be64(entry->e_cluster);
 129
 130                         for (i=0; i<swap_be64(entry->e_blocks); i++)
 131                                 set_bit(ctx->visited, start + i);
 132
 133                         entry++;
 134                 }
 135
 136                 set_bit(ctx->visited, last);
 137                 set_bit(ctx->visited, last+1);
 138
 139                 if (next == ~0)
 140                         break;
 141
 142                 free(buf);
 143                 buf = omfs_get_block(ctx->omfs_info, next);
 144                 if (!buf)
 145                         goto err;
 146                 oe = (struct omfs_extent *) &buf[OMFS_EXTENT_CONT];
 147         }
 148         free(buf);
 149 err:
 150         return;
 151 }
 152
 153 int check_inode(check_context_t *ctx)
 154 {
 155         int i;
 156         int ret = 1;
 157         omfs_inode_t *inode = ctx->current_inode;
 158
 159         if (test_bit(ctx->visited, ctx->block))
 160         {
 161                 fix_problem(E_LOOP, ctx);
 162                 return 0;
 163         }
 164         for (i=0; i < swap_be32(ctx->omfs_info->super->s_mirrors); i++)
 165                 set_bit(ctx->visited, ctx->block + i);
 166
 167         if (!check_sanity(ctx))
 168         {
 169                 fix_problem(E_INSANE, ctx);
 170                 return 0;
 171         }
 172         if (!check_header((u8 *)inode))
 173         {
 174                 fix_problem(E_HEADER_XOR, ctx);
 175                 ret = 0;
 176         }
 177         if (!check_crc((u8 *)inode))
 178         {
 179                 fix_problem(E_HEADER_CRC, ctx);
 180                 ret = 0;
 181         }
 182         if (swap_be64(inode->i_head.h_self) != ctx->block)
 183         {
 184                 fix_problem(E_SELF_PTR, ctx);
 185                 ret = 0;
 186         }
 187         if (swap_be64(inode->i_parent) != ctx->parent)
 188         {
 189                 fix_problem(E_PARENT_PTR, ctx);
 190                 ret = 0;
 191         }
 192         if (omfs_compute_hash(ctx->omfs_info, inode->i_name) != ctx->hash)
 193         {
 194                 fix_problem(E_HASH_WRONG, ctx);
 195                 ret = 0;
 196         }
 197         if (inode->i_type == OMFS_FILE)
 198         {
 199                 visit_extents(ctx);
 200         }
 201
 202         return ret;
 203 }
 204
 205 static int on_node(dirscan_t *d, dirscan_entry_t *entry, void *user)
 206 {
 207         check_context_t *ctx = (check_context_t *) user;
 208
 209         ctx->current_inode = entry->inode;
 210         ctx->block = entry->block;
 211         ctx->parent = entry->parent;
 212         ctx->hash = entry->hindex;
 213         return check_inode(ctx);
 214 }
 215
 216 int check_fs(FILE *fp, check_fs_config_t *config)
 217 {
 218         int res;
 219         check_context_t ctx;
 220         int bsize;
 221         omfs_super_t super;
 222         omfs_root_t root;
 223         omfs_info_t info = {
 224                 .dev = fp,
 225                 .super = &super,
 226                 .root = &root
 227         };
 228
 229         ctx.config = config;
 230
 231         if (omfs_read_super(&info))
 232         {
 233                 fix_problem(E_READ_SUPER, &ctx);
 234                 return 0;
 235         }
 236         if (omfs_read_root_block(&info))
 237         {
 238                 fix_problem(E_READ_ROOT, &ctx);
 239                 return 0;
 240         }
 241
 242         ctx.omfs_info = &info;
 243         omfs_load_bitmap(&info);
 244         ctx.bitmap = info.bitmap->bmap;
 245         bsize = (swap_be64(info.super->s_num_blocks) + 7) / 8;
 246         ctx.visited = calloc(1, bsize);
 247
 248         /* FIXME error codes are all over the place. */
 249         res = dirscan_begin(&info, on_node, &ctx);
 250
 251         if (res < 0)
 252         {
 253                 fix_problem(E_SCAN, &ctx);
 254                 return 0;
 255         }
 256         if (res != 0)
 257                 return 0;
 258
 259         res = check_bitmap(&ctx);
 260
 261         if (ctx.bitmap)
 262                 free(ctx.bitmap);
 263         free(ctx.visited);
 264         return res;
 265 }