debugfs/lsdel.c

   1 /*
   2  * undelete.c --- routines to try to help a user recover a deleted file.
   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 deleted_info {
  21         ino_t   ino;
  22         unsigned short mode;
  23         unsigned short uid;
  24         unsigned long size;
  25         time_t  dtime;
  26         int     num_blocks;
  27         int     free_blocks;
  28 };
  29
  30 struct lsdel_struct {
  31         ino_t                   inode;
  32         int                     num_blocks;
  33         int                     free_blocks;
  34         int                     bad_blocks;
  35 };
  36
  37 int deleted_info_compare(const void *a, const void *b)
  38 {
  39         struct deleted_info *arg1, *arg2;
  40
  41         arg1 = (struct deleted_info *) a;
  42         arg2 = (struct deleted_info *) b;
  43
  44         return arg1->dtime - arg2->dtime;
  45 }
  46
  47 int lsdel_proc(ext2_filsys fs,
  48                blk_t    *block_nr,
  49                int blockcnt,
  50                void *private)
  51 {
  52         struct lsdel_struct *lsd = (struct lsdel_struct *) private;
  53
  54         lsd->num_blocks++;
  55
  56         if (*block_nr < fs->super->s_first_data_block ||
  57             *block_nr >= fs->super->s_blocks_count) {
  58                 lsd->bad_blocks++;
  59                 return BLOCK_ABORT;
  60         }
  61
  62         if (!ext2fs_test_block_bitmap(fs->block_map,*block_nr))
  63                 lsd->free_blocks++;
  64
  65         return 0;
  66 }
  67
  68 void do_lsdel(int argc, char **argv)
  69 {
  70         struct lsdel_struct     lsd;
  71         struct deleted_info     *delarray;
  72         int                     num_delarray, max_delarray;
  73         ext2_inode_scan         scan = 0;
  74         ino_t                   ino;
  75         struct ext2_inode       inode;
  76         errcode_t               retval;
  77         char                    *block_buf;
  78         int                     i;
  79
  80         if (argc > 1) {
  81                 com_err(argv[0], 0, "Usage: ls_deleted_inodes\n");
  82                 return;
  83         }
  84         if (check_fs_open(argv[0]))
  85                 return;
  86
  87         max_delarray = 100;
  88         num_delarray = 0;
  89         delarray = malloc(max_delarray * sizeof(struct deleted_info));
  90         if (!delarray) {
  91                 com_err("ls_deleted_inodes", ENOMEM,
  92                         "while allocating deleted information storage");
  93                 exit(1);
  94         }
  95
  96         block_buf = malloc(fs->blocksize * 3);
  97         if (!block_buf) {
  98                 com_err("ls_deleted_inodes", ENOMEM, "while allocating block buffer");
  99                 goto error_out;
 100         }
 101
 102         retval = ext2fs_open_inode_scan(fs, 0, &scan);
 103         if (retval) {
 104                 com_err("ls_deleted_inodes", retval,
 105                         "while opening inode scan");
 106                 goto error_out;
 107         }
 108
 109         retval = ext2fs_get_next_inode(scan, &ino, &inode);
 110         if (retval) {
 111                 com_err("ls_deleted_inodes", retval,
 112                         "while starting inode scan");
 113                 goto error_out;
 114         }
 115
 116         while (ino) {
 117                 if (inode.i_dtime == 0)
 118                         goto next;
 119
 120                 lsd.inode = ino;
 121                 lsd.num_blocks = 0;
 122                 lsd.free_blocks = 0;
 123                 lsd.bad_blocks = 0;
 124
 125                 retval = ext2fs_block_iterate(fs, ino, 0, block_buf,
 126                                               lsdel_proc, &lsd);
 127                 if (retval) {
 128                         com_err("ls_deleted_inodes", retval,
 129                                 "while calling ext2_block_iterate");
 130                         goto next;
 131                 }
 132                 if (lsd.free_blocks && !lsd.bad_blocks) {
 133                         if (num_delarray >= max_delarray) {
 134                                 max_delarray += 50;
 135                                 delarray = realloc(delarray,
 136                            max_delarray * sizeof(struct deleted_info));
 137                                 if (!delarray) {
 138                                         com_err("ls_deleted_inodes",
 139                                                 ENOMEM,
 140                                                 "while reallocating array");
 141                                         exit(1);
 142                                 }
 143                         }
 144
 145                         delarray[num_delarray].ino = ino;
 146                         delarray[num_delarray].mode = inode.i_mode;
 147                         delarray[num_delarray].uid = inode.i_uid;
 148                         delarray[num_delarray].size = inode.i_size;
 149                         delarray[num_delarray].dtime = inode.i_dtime;
 150                         delarray[num_delarray].num_blocks = lsd.num_blocks;
 151                         delarray[num_delarray].free_blocks = lsd.free_blocks;
 152                         num_delarray++;
 153                 }
 154
 155         next:
 156                 retval = ext2fs_get_next_inode(scan, &ino, &inode);
 157                 if (retval) {
 158                         com_err("ls_deleted_inodes", retval,
 159                                 "while doing inode scan");
 160                         goto error_out;
 161                 }
 162         }
 163
 164         printf("%d deleted inodes found.\n", num_delarray);
 165         printf(" Inode  Owner  Mode    Size    Blocks    Time deleted\n");
 166
 167         qsort(delarray, num_delarray, sizeof(struct deleted_info),
 168               deleted_info_compare);
 169
 170         for (i = 0; i < num_delarray; i++) {
 171                 printf("%6lu %6d %6o %6lu %4d/%4d %s", delarray[i].ino,
 172                        delarray[i].uid, delarray[i].mode, delarray[i].size,
 173                        delarray[i].free_blocks, delarray[i].num_blocks,
 174                        ctime(&delarray[i].dtime));
 175         }
 176
 177 error_out:
 178         free(block_buf);
 179         free(delarray);
 180         if (scan)
 181                 ext2fs_close_inode_scan(scan);
 182         return;
 183 }
 184
 185
 186