debugfs/icheck.c

   1 /*
   2  * icheck.c --- given a list of blocks, generate a list of inodes
   3  *
   4  * Copyright (C) 1994 Theodore Ts'o.  This file may be redistributed
   5  * under the terms of the GNU Public License.
   6  */
   7
   8 #include <stdio.h>
   9 #include <unistd.h>
  10 #include <stdlib.h>
  11 #include <ctype.h>
  12 #include <string.h>
  13 #include <time.h>
  14 #include <getopt.h>
  15 #include <sys/types.h>
  16 #include <sys/stat.h>
  17
  18 #include "debugfs.h"
  19
  20 struct block_info {
  21         blk_t   blk;
  22         ino_t   ino;
  23 };
  24
  25 struct block_walk_struct {
  26         struct block_info       *barray;
  27         int                     blocks_left;
  28         int                     num_blocks;
  29         ino_t                   inode;
  30 };
  31
  32 int icheck_proc(ext2_filsys fs,
  33                 blk_t   *block_nr,
  34                 int blockcnt,
  35                 void *private)
  36 {
  37         struct block_walk_struct *bw = (struct block_walk_struct *) private;
  38         int     i;
  39
  40         for (i=0; i < bw->num_blocks; i++) {
  41                 if (bw->barray[i].blk == *block_nr) {
  42                         bw->barray[i].ino = bw->inode;
  43                         bw->blocks_left--;
  44                 }
  45         }
  46         if (!bw->blocks_left)
  47                 return BLOCK_ABORT;
  48
  49         return 0;
  50 }
  51
  52 void do_icheck(int argc, char **argv)
  53 {
  54         struct block_walk_struct bw;
  55         struct block_info       *binfo;
  56         int                     i;
  57         ext2_inode_scan         scan = 0;
  58         ino_t                   ino;
  59         struct ext2_inode       inode;
  60         errcode_t               retval;
  61         char                    *tmp;
  62         char                    *block_buf;
  63
  64         if (argc < 2) {
  65                 com_err(argv[0], 0, "Usage: icheck <block number> ...");
  66                 return;
  67         }
  68         if (check_fs_open(argv[0]))
  69                 return;
  70
  71         bw.barray = malloc(sizeof(struct block_info) * argc);
  72         if (!bw.barray) {
  73                 com_err("icheck", ENOMEM,
  74                         "while allocating inode info array");
  75                 return;
  76         }
  77         memset(bw.barray, 0, sizeof(struct block_info) * argc);
  78
  79         block_buf = malloc(fs->blocksize * 3);
  80         if (!block_buf) {
  81                 com_err("icheck", ENOMEM, "while allocating block buffer");
  82                 goto error_out;
  83         }
  84
  85         for (i=1; i < argc; i++) {
  86                 bw.barray[i-1].blk = strtol(argv[i], &tmp, 0);
  87                 if (*tmp) {
  88                         com_err(argv[0], 0, "Bad block - %s", argv[i]);
  89                         return;
  90                 }
  91         }
  92
  93         bw.num_blocks = bw.blocks_left = argc-1;
  94
  95         retval = ext2fs_open_inode_scan(fs, 0, &scan);
  96         if (retval) {
  97                 com_err("icheck", retval, "while opening inode scan");
  98                 goto error_out;
  99         }
 100
 101         retval = ext2fs_get_next_inode(scan, &ino, &inode);
 102         if (retval) {
 103                 com_err("icheck", retval, "while starting inode scan");
 104                 goto error_out;
 105         }
 106
 107         while (ino) {
 108                 if (!inode.i_links_count)
 109                         goto next;
 110                 /*
 111                  * To handle filesystems touched by 0.3c extfs; can be
 112                  * removed later.
 113                  */
 114                 if (inode.i_dtime)
 115                         goto next;
 116
 117                 bw.inode = ino;
 118
 119                 retval = ext2fs_block_iterate(fs, ino, 0, block_buf,
 120                                               icheck_proc, &bw);
 121                 if (retval) {
 122                         com_err("icheck", retval,
 123                                 "while calling ext2_block_iterate");
 124                         goto next;
 125                 }
 126
 127                 if (bw.blocks_left == 0)
 128                         break;
 129
 130         next:
 131                 retval = ext2fs_get_next_inode(scan, &ino, &inode);
 132                 if (retval) {
 133                         com_err("icheck", retval,
 134                                 "while doing inode scan");
 135                         goto error_out;
 136                 }
 137         }
 138
 139         printf("Block\tInode number\n");
 140         for (i=0, binfo = bw.barray; i < bw.num_blocks; i++, binfo++) {
 141                 if (binfo->ino == 0) {
 142                         printf("%ld\t<block not found>\n", binfo->blk);
 143                         continue;
 144                 }
 145                 printf("%ld\t%ld\n", binfo->blk, binfo->ino);
 146         }
 147
 148 error_out:
 149         free(bw.barray);
 150         free(block_buf);
 151         if (scan)
 152                 ext2fs_close_inode_scan(scan);
 153         return;
 154 }
 155
 156
 157