Whamcloud - gitweb
Merge branch 'maint' into next
[tools/e2fsprogs.git] / 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         memset(fiemap, 0, sizeof(struct fiemap));
182
183         if (!verbose)
184                 count = 0;
185
186         if (sync_file)
187                 flags |= FIEMAP_FLAG_SYNC;
188
189         if (xattr_map)
190                 flags |= FIEMAP_FLAG_XATTR;
191
192         do {
193                 fiemap->fm_length = ~0ULL;
194                 fiemap->fm_flags = flags;
195                 fiemap->fm_extent_count = count;
196                 rc = ioctl(fd, FS_IOC_FIEMAP, (unsigned long) fiemap);
197                 if (rc < 0) {
198                         if (errno == EBADR && fiemap_incompat_printed == 0) {
199                                 printf("FIEMAP failed with unsupported "
200                                        "flags %x\n", fiemap->fm_flags);
201                                 fiemap_incompat_printed = 1;
202                         }
203                         return rc;
204                 }
205
206                 if (verbose && !fiemap_header_printed) {
207                         printf(" ext %*s %*s %*s length flags\n", logical_width,
208                                "logical", physical_width, "physical",
209                                physical_width, "expected");
210                         fiemap_header_printed = 1;
211                 }
212
213                 if (!verbose) {
214                         *num_extents = fiemap->fm_mapped_extents;
215                         goto out;
216                 }
217
218                 /* If 0 extents are returned, then more ioctls are not needed */
219                 if (fiemap->fm_mapped_extents == 0)
220                         break;
221
222                 for (i = 0; i < fiemap->fm_mapped_extents; i++) {
223                         __u64 phy_blk, logical_blk;
224                         unsigned long ext_len;
225
226                         phy_blk = fm_ext[i].fe_physical >> blk_shift;
227                         ext_len = fm_ext[i].fe_length >> blk_shift;
228                         logical_blk = fm_ext[i].fe_logical >> blk_shift;
229
230                         if (logical_blk && phy_blk != last_blk + 1)
231                                 tot_extents++;
232                         else
233                                 last_blk = 0;
234                         print_extent_info(&fm_ext[i], n, last_blk, blk_shift);
235
236                         last_blk = phy_blk + ext_len - 1;
237                         if (fm_ext[i].fe_flags & FIEMAP_EXTENT_LAST)
238                                 last = 1;
239                         n++;
240                 }
241
242                 fiemap->fm_start = (fm_ext[i-1].fe_logical +
243                                     fm_ext[i-1].fe_length);
244         } while (last == 0);
245
246         *num_extents = tot_extents;
247 out:
248         return 0;
249 }
250
251 #define EXT2_DIRECT     12
252
253 static void frag_report(const char *filename)
254 {
255         struct statfs   fsinfo;
256 #ifdef HAVE_FSTAT64
257         struct stat64   fileinfo;
258 #else
259         struct stat     fileinfo;
260 #endif
261         int             bs;
262         long            fd;
263         unsigned long   block, last_block = 0, numblocks, i, count;
264         long            bpib;   /* Blocks per indirect block */
265         long            cylgroups;
266         int             num_extents = 0, expected;
267         int             is_ext2 = 0;
268         static int      once = 1;
269         unsigned int    flags;
270         int rc;
271
272 #ifdef HAVE_OPEN64
273         fd = open64(filename, O_RDONLY);
274 #else
275         fd = open(filename, O_RDONLY);
276 #endif
277         if (fd < 0) {
278                 perror("open");
279                 return;
280         }
281
282         if (statfs(filename, &fsinfo) < 0) {
283                 perror("statfs");
284                 return;
285         }
286 #ifdef HAVE_FSTAT64
287         if (stat64(filename, &fileinfo) < 0) {
288 #else
289         if (stat(filename, &fileinfo) < 0) {
290 #endif
291                 perror("stat");
292                 return;
293         }
294         if (ioctl(fd, EXT3_IOC_GETFLAGS, &flags) < 0)
295                 flags = 0;
296         if (!(flags & EXT4_EXTENTS_FL) &&
297             ((fsinfo.f_type == 0xef51) || (fsinfo.f_type == 0xef52) ||
298              (fsinfo.f_type == 0xef53)))
299                 is_ext2++;
300         if (verbose && once)
301                 printf("Filesystem type is: %lx\n",
302                        (unsigned long) fsinfo.f_type);
303
304         cylgroups = div_ceil(fsinfo.f_blocks, fsinfo.f_bsize*8);
305         if (verbose && is_ext2 && once)
306                 printf("Filesystem cylinder groups is approximately %ld\n",
307                        cylgroups);
308
309         physical_width = int_log10(fsinfo.f_blocks);
310         if (physical_width < 8)
311                 physical_width = 8;
312
313         if (ioctl(fd, FIGETBSZ, &bs) < 0) { /* FIGETBSZ takes an int */
314                 perror("FIGETBSZ");
315                 close(fd);
316                 return;
317         }
318
319         if (no_bs)
320                 bs = 1024;
321
322         bpib = bs / 4;
323         numblocks = (fileinfo.st_size + (bs-1)) / bs;
324         logical_width = int_log10(numblocks);
325         if (logical_width < 7)
326                 logical_width = 7;
327         filesize = (long long)fileinfo.st_size;
328         if (verbose)
329                 printf("File size of %s is %lld (%ld block%s, blocksize %d)\n",
330                        filename, (long long) fileinfo.st_size, numblocks,
331                        numblocks == 1 ? "" : "s", bs);
332         if (force_bmap ||
333             filefrag_fiemap(fd, int_log2(bs), &num_extents) != 0) {
334                 for (i = 0, count = 0; i < numblocks; i++) {
335                         if (is_ext2 && last_block) {
336                                 if (((i-EXT2_DIRECT) % bpib) == 0)
337                                         last_block++;
338                                 if (((i-EXT2_DIRECT-bpib) % (bpib*bpib)) == 0)
339                                         last_block++;
340                                 if (((i-EXT2_DIRECT-bpib-bpib*bpib) %
341                                      (((__u64) bpib)*bpib*bpib)) == 0)
342                                         last_block++;
343                         }
344                         rc = get_bmap(fd, i, &block);
345                         if (block == 0)
346                                 continue;
347                         if (!num_extents)
348                                 num_extents++;
349                         count++;
350                         if (last_block && (block != last_block+1) ) {
351                                 if (verbose)
352                                         printf("Discontinuity: Block %ld is at "
353                                                "%lu (was %lu)\n",
354                                                i, block, last_block+1);
355                                 num_extents++;
356                         }
357                         last_block = block;
358                 }
359         }
360         if (num_extents == 1)
361                 printf("%s: 1 extent found", filename);
362         else
363                 printf("%s: %d extents found", filename, num_extents);
364         expected = (count/((bs*8)-(fsinfo.f_files/8/cylgroups)-3))+1;
365         if (is_ext2 && expected < num_extents)
366                 printf(", perfection would be %d extent%s\n", expected,
367                         (expected>1) ? "s" : "");
368         else
369                 fputc('\n', stdout);
370         close(fd);
371         once = 0;
372 }
373
374 static void usage(const char *progname)
375 {
376         fprintf(stderr, "Usage: %s [-Bbvsx] file ...\n", progname);
377         exit(1);
378 }
379
380 int main(int argc, char**argv)
381 {
382         char **cpp;
383         int c;
384
385         while ((c = getopt(argc, argv, "Bbsvx")) != EOF)
386                 switch (c) {
387                 case 'B':
388                         force_bmap++;
389                         break;
390                 case 'b':
391                         no_bs++;
392                         break;
393                 case 'v':
394                         verbose++;
395                         break;
396                 case 's':
397                         sync_file++;
398                         break;
399                 case 'x':
400                         xattr_map++;
401                         break;
402                 default:
403                         usage(argv[0]);
404                         break;
405                 }
406         if (optind == argc)
407                 usage(argv[0]);
408         for (cpp=argv+optind; *cpp; cpp++)
409                 frag_report(*cpp);
410         return 0;
411 }
412 #endif