debugfs/lsdel.c

   1 /*
   2  * lsdel.c --- routines to try to help a user recover a deleted file.
   3  *
   4  * Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
   5  * Theodore Ts'o.  This file may be redistributed under the terms of
   6  * the GNU Public License.
   7  */
   8
   9 #include "config.h"
  10 #include <stdio.h>
  11 #include <unistd.h>
  12 #include <stdlib.h>
  13 #include <ctype.h>
  14 #include <string.h>
  15 #include <time.h>
  16 #ifdef HAVE_ERRNO_H
  17 #include <errno.h>
  18 #endif
  19 #include <sys/types.h>
  20 #include <sys/stat.h>
  21
  22 #include "debugfs.h"
  23
  24 struct deleted_info {
  25         ext2_ino_t      ino;
  26         unsigned short  mode;
  27         __u32           uid;
  28         __u64           size;
  29         time_t          dtime;
  30         e2_blkcnt_t     num_blocks;
  31         e2_blkcnt_t     free_blocks;
  32 };
  33
  34 struct lsdel_struct {
  35         ext2_ino_t              inode;
  36         e2_blkcnt_t             num_blocks;
  37         e2_blkcnt_t             free_blocks;
  38         e2_blkcnt_t             bad_blocks;
  39 };
  40
  41 static int deleted_info_compare(const void *a, const void *b)
  42 {
  43         const struct deleted_info *arg1, *arg2;
  44
  45         arg1 = (const struct deleted_info *) a;
  46         arg2 = (const struct deleted_info *) b;
  47
  48         return arg1->dtime - arg2->dtime;
  49 }
  50
  51 static int lsdel_proc(ext2_filsys fs,
  52                       blk64_t   *block_nr,
  53                       e2_blkcnt_t blockcnt EXT2FS_ATTR((unused)),
  54                       blk64_t ref_block EXT2FS_ATTR((unused)),
  55                       int ref_offset EXT2FS_ATTR((unused)),
  56                       void *private)
  57 {
  58         struct lsdel_struct *lsd = (struct lsdel_struct *) private;
  59
  60         lsd->num_blocks++;
  61
  62         if (*block_nr < fs->super->s_first_data_block ||
  63             *block_nr >= ext2fs_blocks_count(fs->super)) {
  64                 lsd->bad_blocks++;
  65                 return BLOCK_ABORT;
  66         }
  67
  68         if (!ext2fs_test_block_bitmap2(fs->block_map,*block_nr))
  69                 lsd->free_blocks++;
  70
  71         return 0;
  72 }
  73
  74 void do_lsdel(int argc, char **argv)
  75 {
  76         struct lsdel_struct     lsd;
  77         struct deleted_info     *delarray;
  78         int                     num_delarray, max_delarray;
  79         ext2_inode_scan         scan = 0;
  80         ext2_ino_t              ino;
  81         struct ext2_inode       *inode = NULL;
  82         int                     inode_size;
  83         errcode_t               retval;
  84         char                    *block_buf;
  85         int                     i;
  86         long                    secs = 0;
  87         char                    *tmp;
  88         time_t                  now;
  89         FILE                    *out;
  90
  91         if (common_args_process(argc, argv, 1, 2, "list_deleted_inodes",
  92                                 "[secs]", 0))
  93                 return;
  94
  95         if (argc > 1) {
  96                 secs = strtol(argv[1],&tmp,0);
  97                 if (*tmp) {
  98                         com_err(argv[0], 0, "Bad time - %s",argv[1]);
  99                         return;
 100                 }
 101         }
 102
 103         now = current_fs->now ? current_fs->now : time(0);
 104         max_delarray = 100;
 105         num_delarray = 0;
 106         delarray = malloc(max_delarray * sizeof(struct deleted_info));
 107         if (!delarray) {
 108                 com_err("ls_deleted_inodes", ENOMEM,
 109                         "while allocating deleted information storage");
 110                 exit(1);
 111         }
 112
 113         block_buf = malloc(current_fs->blocksize * 3);
 114         if (!block_buf) {
 115                 com_err("ls_deleted_inodes", ENOMEM, "while allocating block buffer");
 116                 goto error_out;
 117         }
 118
 119         retval = ext2fs_open_inode_scan(current_fs, 0, &scan);
 120         if (retval) {
 121                 com_err("ls_deleted_inodes", retval,
 122                         "while opening inode scan");
 123                 goto error_out;
 124         }
 125         inode_size = EXT2_INODE_SIZE(current_fs->super);
 126         retval = ext2fs_get_mem(inode_size, &inode);
 127         if (retval)
 128                 goto error_out;
 129
 130         do {
 131                 retval = ext2fs_get_next_inode_full(scan, &ino,
 132                                                     inode, inode_size);
 133         } while (retval == EXT2_ET_BAD_BLOCK_IN_INODE_TABLE);
 134         if (retval) {
 135                 com_err("ls_deleted_inodes", retval,
 136                         "while starting inode scan");
 137                 goto error_out;
 138         }
 139
 140         while (ino) {
 141                 if ((inode->i_dtime == 0) ||
 142                     (secs && ((unsigned) abs(now - secs) > inode->i_dtime)))
 143                         goto next;
 144
 145                 lsd.inode = ino;
 146                 lsd.num_blocks = 0;
 147                 lsd.free_blocks = 0;
 148                 lsd.bad_blocks = 0;
 149
 150                 retval = ext2fs_block_iterate3(current_fs, ino,
 151                                                BLOCK_FLAG_READ_ONLY, block_buf,
 152                                                lsdel_proc, &lsd);
 153                 if (retval) {
 154                         com_err("ls_deleted_inodes", retval,
 155                                 "while calling ext2fs_block_iterate2");
 156                         goto next;
 157                 }
 158                 if (lsd.free_blocks && !lsd.bad_blocks) {
 159                         if (num_delarray >= max_delarray) {
 160                                 max_delarray += 50;
 161                                 delarray = realloc(delarray,
 162                            max_delarray * sizeof(struct deleted_info));
 163                                 if (!delarray) {
 164                                         com_err("ls_deleted_inodes",
 165                                                 ENOMEM,
 166                                                 "while reallocating array");
 167                                         exit(1);
 168                                 }
 169                         }
 170
 171                         delarray[num_delarray].ino = ino;
 172                         delarray[num_delarray].mode = inode->i_mode;
 173                         delarray[num_delarray].uid = inode_uid(*inode);
 174                         delarray[num_delarray].size = EXT2_I_SIZE(inode);
 175                         delarray[num_delarray].dtime = inode->i_dtime;
 176                         delarray[num_delarray].num_blocks = lsd.num_blocks;
 177                         delarray[num_delarray].free_blocks = lsd.free_blocks;
 178                         num_delarray++;
 179                 }
 180
 181         next:
 182                 do {
 183                         retval = ext2fs_get_next_inode_full(scan, &ino,
 184                                                         inode, inode_size);
 185                 } while (retval == EXT2_ET_BAD_BLOCK_IN_INODE_TABLE);
 186                 if (retval) {
 187                         com_err("ls_deleted_inodes", retval,
 188                                 "while doing inode scan");
 189                         goto error_out;
 190                 }
 191         }
 192
 193         out = open_pager();
 194
 195         fprintf(out, " Inode  Owner  Mode    Size      Blocks   Time deleted\n");
 196
 197         qsort(delarray, num_delarray, sizeof(struct deleted_info),
 198               deleted_info_compare);
 199
 200         for (i = 0; i < num_delarray; i++) {
 201                 fprintf(out, "%6u %6d %6o %6llu %6lld/%6lld %s",
 202                         delarray[i].ino,
 203                         delarray[i].uid, delarray[i].mode, delarray[i].size,
 204                         delarray[i].free_blocks, delarray[i].num_blocks,
 205                         time_to_string(delarray[i].dtime));
 206         }
 207         fprintf(out, "%d deleted inodes found.\n", num_delarray);
 208         close_pager(out);
 209
 210 error_out:
 211         ext2fs_free_mem(&inode);
 212         free(block_buf);
 213         free(delarray);
 214         if (scan)
 215                 ext2fs_close_inode_scan(scan);
 216         return;
 217 }
 218
 219
 220