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