misc/filefrag.c

   1 /*
   2  * filefrag.c -- report if a particular file is fragmented
   3  *
   4  * Copyright 2003 by Theodore Ts'o.
   5  *
   6  * %Begin-Header%
   7  * This file may be redistributed under the terms of the GNU Public
   8  * License.
   9  * %End-Header%
  10  */
  11
  12 #ifndef __linux__
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <unistd.h>
  16
  17 int main(void) {
  18     fputs("This program is only supported on Linux!\n", stderr);
  19     exit(EXIT_FAILURE);
  20 }
  21 #else
  22 #define _LARGEFILE64_SOURCE
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <unistd.h>
  27 #include <string.h>
  28 #include <time.h>
  29 #include <fcntl.h>
  30 #include <errno.h>
  31 #ifdef HAVE_GETOPT_H
  32 #include <getopt.h>
  33 #else
  34 extern char *optarg;
  35 extern int optind;
  36 #endif
  37 #include <sys/types.h>
  38 #include <sys/stat.h>
  39 #include <sys/vfs.h>
  40 #include <sys/ioctl.h>
  41 #include <linux/fd.h>
  42 #include <ext2fs/ext2_types.h>
  43 #include <ext2fs/fiemap.h>
  44
  45 int verbose = 0;
  46 int no_bs = 0;          /* Don't use the files blocksize, use 1K blocksize */
  47 int sync_file = 0;      /* fsync file before getting the mapping */
  48 int xattr_map = 0;      /* get xattr mapping */
  49 int force_bmap = 0;
  50 int logical_width = 12;
  51 int physical_width = 14;
  52 unsigned long long filesize;
  53
  54 #define FILEFRAG_FIEMAP_FLAGS_COMPAT (FIEMAP_FLAG_SYNC | FIEMAP_FLAG_XATTR)
  55
  56 #define FIBMAP          _IO(0x00, 1)    /* bmap access */
  57 #define FIGETBSZ        _IO(0x00, 2)    /* get the block size used for bmap */
  58
  59 #define EXT4_EXTENTS_FL                 0x00080000 /* Inode uses extents */
  60 #define EXT3_IOC_GETFLAGS               _IOR('f', 1, long)
  61
  62 static int int_log2(int arg)
  63 {
  64         int     l = 0;
  65
  66         arg >>= 1;
  67         while (arg) {
  68                 l++;
  69                 arg >>= 1;
  70         }
  71         return l;
  72 }
  73
  74 static int int_log10(unsigned long long arg)
  75 {
  76         int     l = 0;
  77
  78         arg = arg / 10;
  79         while (arg) {
  80                 l++;
  81                 arg = arg / 10;
  82         }
  83         return l;
  84 }
  85
  86 static unsigned int div_ceil(unsigned int a, unsigned int b)
  87 {
  88         if (!a)
  89                 return 0;
  90         return ((a - 1) / b) + 1;
  91 }
  92
  93 static int get_bmap(int fd, unsigned long block, unsigned long *phy_blk)
  94 {
  95         int     ret;
  96         unsigned int b;
  97
  98         b = block;
  99         ret = ioctl(fd, FIBMAP, &b); /* FIBMAP takes pointer to integer */
 100         if (ret < 0) {
 101                 if (errno == EPERM) {
 102                         fprintf(stderr, "No permission to use FIBMAP ioctl; "
 103                                 "must have root privileges\n");
 104                         exit(1);
 105                 }
 106                 perror("FIBMAP");
 107         }
 108         *phy_blk = b;
 109
 110         return ret;
 111 }
 112
 113 static void print_extent_info(struct fiemap_extent *fm_extent, int cur_ex,
 114                               unsigned long long expected, int blk_shift)
 115 {
 116         __u64 phy_blk;
 117         unsigned long long logical_blk;
 118         unsigned long ext_len;
 119         char flags[256] = "";
 120
 121         /* For inline data all offsets should be in terms of bytes, not blocks */
 122         if (fm_extent->fe_flags & FIEMAP_EXTENT_DATA_INLINE)
 123                 blk_shift = 0;
 124
 125         ext_len = fm_extent->fe_length >> blk_shift;
 126         logical_blk = fm_extent->fe_logical >> blk_shift;
 127         phy_blk = fm_extent->fe_physical >> blk_shift;
 128
 129         if (fm_extent->fe_flags & FIEMAP_EXTENT_UNKNOWN)
 130                 strcat(flags, "unknown,");
 131         if (fm_extent->fe_flags & FIEMAP_EXTENT_DELALLOC)
 132                 strcat(flags, "delalloc,");
 133         if (fm_extent->fe_flags & FIEMAP_EXTENT_DATA_ENCRYPTED)
 134                 strcat(flags, "encrypted,");
 135         if (fm_extent->fe_flags & FIEMAP_EXTENT_NOT_ALIGNED)
 136                 strcat(flags, "not_aligned,");
 137         if (fm_extent->fe_flags & FIEMAP_EXTENT_DATA_INLINE)
 138                 strcat(flags, "inline,");
 139         if (fm_extent->fe_flags & FIEMAP_EXTENT_DATA_TAIL)
 140                 strcat(flags, "tail_packed,");
 141         if (fm_extent->fe_flags & FIEMAP_EXTENT_UNWRITTEN)
 142                 strcat(flags, "unwritten,");
 143         if (fm_extent->fe_flags & FIEMAP_EXTENT_MERGED)
 144                 strcat(flags, "merged,");
 145
 146         if (fm_extent->fe_logical + fm_extent->fe_length >= filesize)
 147                 strcat(flags, "eof,");
 148
 149         /* Remove trailing comma, if any */
 150         if (flags[0])
 151                 flags[strlen(flags) - 1] = '\0';
 152
 153         if (expected)
 154                 printf("%4d %*llu %*llu %*llu %6lu %s\n",
 155                        cur_ex, logical_width, logical_blk,
 156                        physical_width, phy_blk, physical_width, expected,
 157                        ext_len, flags);
 158         else
 159                 printf("%4d %*llu %*llu %*s %6lu %s\n",
 160                        cur_ex, logical_width, logical_blk,
 161                        physical_width, phy_blk, physical_width, "",
 162                        ext_len, flags);
 163 }
 164
 165 static int filefrag_fiemap(int fd, int blk_shift, int *num_extents)
 166 {
 167         char buf[4096] = "";
 168         struct fiemap *fiemap = (struct fiemap *)buf;
 169         struct fiemap_extent *fm_ext = &fiemap->fm_extents[0];
 170         int count = (sizeof(buf) - sizeof(*fiemap)) /
 171                         sizeof(struct fiemap_extent);
 172         unsigned long long last_blk = 0;
 173         unsigned long flags = 0;
 174         unsigned int i;
 175         static int fiemap_incompat_printed;
 176         int fiemap_header_printed = 0;
 177         int tot_extents = 1, n = 0;
 178         int last = 0;
 179         int rc;
 180
 181         fiemap->fm_length = ~0ULL;
 182
 183         memset(fiemap, 0, sizeof(struct fiemap));
 184
 185         if (!verbose)
 186                 count = 0;
 187
 188         if (sync_file)
 189                 flags |= FIEMAP_FLAG_SYNC;
 190
 191         if (xattr_map)
 192                 flags |= FIEMAP_FLAG_XATTR;
 193
 194         do {
 195                 fiemap->fm_length = ~0ULL;
 196                 fiemap->fm_flags = flags;
 197                 fiemap->fm_extent_count = count;
 198                 rc = ioctl(fd, FS_IOC_FIEMAP, (unsigned long) fiemap);
 199                 if (rc < 0) {
 200                         if (errno == EBADR && fiemap_incompat_printed == 0) {
 201                                 printf("FIEMAP failed with unsupported "
 202                                        "flags %x\n", fiemap->fm_flags);
 203                                 fiemap_incompat_printed = 1;
 204                         }
 205                         return rc;
 206                 }
 207
 208                 if (verbose && !fiemap_header_printed) {
 209                         printf(" ext %*s %*s %*s length flags\n", logical_width,
 210                                "logical", physical_width, "physical",
 211                                physical_width, "expected");
 212                         fiemap_header_printed = 1;
 213                 }
 214
 215                 if (!verbose) {
 216                         *num_extents = fiemap->fm_mapped_extents;
 217                         goto out;
 218                 }
 219
 220                 /* If 0 extents are returned, then more ioctls are not needed */
 221                 if (fiemap->fm_mapped_extents == 0)
 222                         break;
 223
 224                 for (i = 0; i < fiemap->fm_mapped_extents; i++) {
 225                         __u64 phy_blk, logical_blk;
 226                         unsigned long ext_len;
 227
 228                         phy_blk = fm_ext[i].fe_physical >> blk_shift;
 229                         ext_len = fm_ext[i].fe_length >> blk_shift;
 230                         logical_blk = fm_ext[i].fe_logical >> blk_shift;
 231
 232                         if (logical_blk && phy_blk != last_blk + 1)
 233                                 tot_extents++;
 234                         else
 235                                 last_blk = 0;
 236                         print_extent_info(&fm_ext[i], n, last_blk, blk_shift);
 237
 238                         last_blk = phy_blk + ext_len - 1;
 239                         if (fm_ext[i].fe_flags & FIEMAP_EXTENT_LAST)
 240                                 last = 1;
 241                         n++;
 242                 }
 243
 244                 fiemap->fm_start = (fm_ext[i-1].fe_logical +
 245                                     fm_ext[i-1].fe_length);
 246         } while (last == 0);
 247
 248         *num_extents = tot_extents;
 249 out:
 250         return 0;
 251 }
 252
 253 #define EXT2_DIRECT     12
 254
 255 static void frag_report(const char *filename)
 256 {
 257         struct statfs   fsinfo;
 258 #ifdef HAVE_FSTAT64
 259         struct stat64   fileinfo;
 260 #else
 261         struct stat     fileinfo;
 262 #endif
 263         int             bs;
 264         long            fd;
 265         unsigned long   block, last_block = 0, numblocks, i, count;
 266         long            bpib;   /* Blocks per indirect block */
 267         long            cylgroups;
 268         int             num_extents = 0, expected;
 269         int             is_ext2 = 0;
 270         static int      once = 1;
 271         unsigned int    flags;
 272         int rc;
 273
 274 #ifdef HAVE_OPEN64
 275         fd = open64(filename, O_RDONLY);
 276 #else
 277         fd = open(filename, O_RDONLY);
 278 #endif
 279         if (fd < 0) {
 280                 perror("open");
 281                 return;
 282         }
 283
 284         if (statfs(filename, &fsinfo) < 0) {
 285                 perror("statfs");
 286                 return;
 287         }
 288 #ifdef HAVE_FSTAT64
 289         if (stat64(filename, &fileinfo) < 0) {
 290 #else
 291         if (stat(filename, &fileinfo) < 0) {
 292 #endif
 293                 perror("stat");
 294                 return;
 295         }
 296         if (ioctl(fd, EXT3_IOC_GETFLAGS, &flags) < 0)
 297                 flags = 0;
 298         if (!(flags & EXT4_EXTENTS_FL) &&
 299             ((fsinfo.f_type == 0xef51) || (fsinfo.f_type == 0xef52) ||
 300              (fsinfo.f_type == 0xef53)))
 301                 is_ext2++;
 302         if (verbose && once)
 303                 printf("Filesystem type is: %lx\n",
 304                        (unsigned long) fsinfo.f_type);
 305
 306         cylgroups = div_ceil(fsinfo.f_blocks, fsinfo.f_bsize*8);
 307         if (verbose && is_ext2 && once)
 308                 printf("Filesystem cylinder groups is approximately %ld\n",
 309                        cylgroups);
 310
 311         physical_width = int_log10(fsinfo.f_blocks);
 312         if (physical_width < 8)
 313                 physical_width = 8;
 314
 315         if (ioctl(fd, FIGETBSZ, &bs) < 0) { /* FIGETBSZ takes an int */
 316                 perror("FIGETBSZ");
 317                 close(fd);
 318                 return;
 319         }
 320
 321         if (no_bs)
 322                 bs = 1024;
 323
 324         bpib = bs / 4;
 325         numblocks = (fileinfo.st_size + (bs-1)) / bs;
 326         logical_width = int_log10(numblocks);
 327         if (logical_width < 7)
 328                 logical_width = 7;
 329         filesize = (long long)fileinfo.st_size;
 330         if (verbose)
 331                 printf("File size of %s is %lld (%ld block%s, blocksize %d)\n",
 332                        filename, (long long) fileinfo.st_size, numblocks,
 333                        numblocks == 1 ? "" : "s", bs);
 334         if (force_bmap ||
 335             filefrag_fiemap(fd, int_log2(bs), &num_extents) != 0) {
 336                 for (i = 0, count = 0; i < numblocks; i++) {
 337                         if (is_ext2 && last_block) {
 338                                 if (((i-EXT2_DIRECT) % bpib) == 0)
 339                                         last_block++;
 340                                 if (((i-EXT2_DIRECT-bpib) % (bpib*bpib)) == 0)
 341                                         last_block++;
 342                                 if (((i-EXT2_DIRECT-bpib-bpib*bpib) %
 343                                      (((__u64) bpib)*bpib*bpib)) == 0)
 344                                         last_block++;
 345                         }
 346                         rc = get_bmap(fd, i, &block);
 347                         if (block == 0)
 348                                 continue;
 349                         if (!num_extents)
 350                                 num_extents++;
 351                         count++;
 352                         if (last_block && (block != last_block+1) ) {
 353                                 if (verbose)
 354                                         printf("Discontinuity: Block %ld is at "
 355                                                "%lu (was %lu)\n",
 356                                                i, block, last_block+1);
 357                                 num_extents++;
 358                         }
 359                         last_block = block;
 360                 }
 361         }
 362         if (num_extents == 1)
 363                 printf("%s: 1 extent found", filename);
 364         else
 365                 printf("%s: %d extents found", filename, num_extents);
 366         expected = (count/((bs*8)-(fsinfo.f_files/8/cylgroups)-3))+1;
 367         if (is_ext2 && expected < num_extents)
 368                 printf(", perfection would be %d extent%s\n", expected,
 369                         (expected>1) ? "s" : "");
 370         else
 371                 fputc('\n', stdout);
 372         close(fd);
 373         once = 0;
 374 }
 375
 376 static void usage(const char *progname)
 377 {
 378         fprintf(stderr, "Usage: %s [-Bbvsx] file ...\n", progname);
 379         exit(1);
 380 }
 381
 382 int main(int argc, char**argv)
 383 {
 384         char **cpp;
 385         int c;
 386
 387         while ((c = getopt(argc, argv, "Bbsvx")) != EOF)
 388                 switch (c) {
 389                 case 'B':
 390                         force_bmap++;
 391                         break;
 392                 case 'b':
 393                         no_bs++;
 394                         break;
 395                 case 'v':
 396                         verbose++;
 397                         break;
 398                 case 's':
 399                         sync_file++;
 400                         break;
 401                 case 'x':
 402                         xattr_map++;
 403                         break;
 404                 default:
 405                         usage(argv[0]);
 406                         break;
 407                 }
 408         if (optind == argc)
 409                 usage(argv[0]);
 410         for (cpp=argv+optind; *cpp; cpp++)
 411                 frag_report(*cpp);
 412         return 0;
 413 }
 414 #endif