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