2 * fallocate - utility to use the fallocate system call
4 * Copyright (C) 2008-2009 Red Hat, Inc. All rights reserved.
5 * Written by Eric Sandeen <sandeen@redhat.com>
6 * Karel Zak <kzak@redhat.com>
8 * cvtnum routine taken from xfsprogs,
9 * Copyright (c) 2003-2005 Silicon Graphics, Inc.
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License as
13 * published by the Free Software Foundation.
15 * This program is distributed in the hope that it would be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License along
21 * with this program; if not, write to the Free Software Foundation, Inc.,
22 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
25 #include <sys/types.h>
37 #ifndef HAVE_FALLOCATE
38 # include <sys/syscall.h>
41 #if defined(HAVE_LINUX_FALLOC_H) && \
42 (!defined(FALLOC_FL_KEEP_SIZE) || !defined(FALLOC_FL_PUNCH_HOLE) || \
43 !defined(FALLOC_FL_COLLAPSE_RANGE) || !defined(FALLOC_FL_ZERO_RANGE) || \
44 !defined(FALLOC_FL_INSERT_RANGE))
45 # include <linux/falloc.h> /* non-libc fallback for FALLOC_FL_* flags */
49 #ifndef FALLOC_FL_KEEP_SIZE
50 # define FALLOC_FL_KEEP_SIZE 0x1
53 #ifndef FALLOC_FL_PUNCH_HOLE
54 # define FALLOC_FL_PUNCH_HOLE 0x2
57 #ifndef FALLOC_FL_COLLAPSE_RANGE
58 # define FALLOC_FL_COLLAPSE_RANGE 0x8
61 #ifndef FALLOC_FL_ZERO_RANGE
62 # define FALLOC_FL_ZERO_RANGE 0x10
65 #ifndef FALLOC_FL_INSERT_RANGE
66 # define FALLOC_FL_INSERT_RANGE 0x20
72 #include "closestream.h"
77 static char *filename
;
79 static void __attribute__((__noreturn__
)) usage(void)
82 fputs(USAGE_HEADER
, out
);
84 _(" %s [options] <filename>\n"), program_invocation_short_name
);
86 fputs(USAGE_SEPARATOR
, out
);
87 fputs(_("Preallocate space to, or deallocate space from a file.\n"), out
);
89 fputs(USAGE_OPTIONS
, out
);
90 fputs(_(" -c, --collapse-range remove a range from the file\n"), out
);
91 fputs(_(" -d, --dig-holes detect zeroes and replace with holes\n"), out
);
92 fputs(_(" -i, --insert-range insert a hole at range, shifting existing data\n"), out
);
93 fputs(_(" -l, --length <num> length for range operations, in bytes\n"), out
);
94 fputs(_(" -n, --keep-size maintain the apparent size of the file\n"), out
);
95 fputs(_(" -o, --offset <num> offset for range operations, in bytes\n"), out
);
96 fputs(_(" -p, --punch-hole replace a range with a hole (implies -n)\n"), out
);
97 fputs(_(" -z, --zero-range zero and ensure allocation of a range\n"), out
);
98 #ifdef HAVE_POSIX_FALLOCATE
99 fputs(_(" -x, --posix use posix_fallocate(3) instead of fallocate(2)\n"), out
);
101 fputs(_(" -v, --verbose verbose mode\n"), out
);
103 fputs(USAGE_SEPARATOR
, out
);
104 fprintf(out
, USAGE_HELP_OPTIONS(22));
106 fputs(USAGE_ARGUMENTS
, out
);
107 fprintf(out
, USAGE_ARG_SIZE(_("<num>")));
109 fprintf(out
, USAGE_MAN_TAIL("fallocate(1)"));
114 static loff_t
cvtnum(char *s
)
118 if (strtosize(s
, &x
))
124 static void xfallocate(int fd
, int mode
, off_t offset
, off_t length
)
128 #ifdef HAVE_FALLOCATE
129 error
= fallocate(fd
, mode
, offset
, length
);
131 error
= syscall(SYS_fallocate
, fd
, mode
, offset
, length
);
134 * EOPNOTSUPP: The FALLOC_FL_KEEP_SIZE is unsupported
135 * ENOSYS: The filesystem does not support sys_fallocate
138 if ((mode
& FALLOC_FL_KEEP_SIZE
) && errno
== EOPNOTSUPP
)
139 errx(EXIT_FAILURE
, _("fallocate failed: keep size mode is unsupported"));
140 err(EXIT_FAILURE
, _("fallocate failed"));
144 #ifdef HAVE_POSIX_FALLOCATE
145 static void xposix_fallocate(int fd
, off_t offset
, off_t length
)
147 errno
= posix_fallocate(fd
, offset
, length
);
149 err(EXIT_FAILURE
, _("fallocate failed"));
154 /* The real buffer size has to be bufsize + sizeof(uintptr_t) */
155 static int is_nul(void *buf
, size_t bufsize
)
157 typedef uintptr_t word
;
159 char const *cbuf
= buf
, *cp
;
160 word
const *wp
= buf
;
163 memset((char *) buf
+ bufsize
, '\1', sizeof(word
));
165 /* Find first nonzero *word*, or the word with the sentinel. */
169 /* Find the first nonzero *byte*, or the sentinel. */
176 return cbuf
+ bufsize
< cp
;
179 static void dig_holes(int fd
, off_t file_off
, off_t len
)
181 off_t file_end
= len
? file_off
+ len
: 0;
182 off_t hole_start
= 0, hole_sz
= 0;
187 #if defined(POSIX_FADV_SEQUENTIAL) && defined(HAVE_POSIX_FADVISE)
188 off_t cache_start
= file_off
;
190 * We don't want to call POSIX_FADV_DONTNEED to discard cached
191 * data in PAGE_SIZE steps. IMHO it's overkill (too many syscalls).
193 * Let's assume that 1MiB (on system with 4K page size) is just
197 const size_t cachesz
= getpagesize() * 256;
200 if (fstat(fd
, &st
) != 0)
201 err(EXIT_FAILURE
, _("stat of %s failed"), filename
);
203 bufsz
= st
.st_blksize
;
205 if (lseek(fd
, file_off
, SEEK_SET
) < 0)
206 err(EXIT_FAILURE
, _("seek on %s failed"), filename
);
208 /* buffer + extra space for is_nul() sentinel */
209 buf
= xmalloc(bufsz
+ sizeof(uintptr_t));
210 while (file_end
== 0 || file_off
< file_end
) {
212 * Detect data area (skip holes)
216 off
= lseek(fd
, file_off
, SEEK_DATA
);
217 if ((off
== -1 && errno
== ENXIO
) ||
218 (file_end
&& off
>= file_end
))
221 end
= lseek(fd
, off
, SEEK_HOLE
);
222 if (file_end
&& end
> file_end
)
225 if (off
< 0 || end
< 0)
228 #if defined(POSIX_FADV_SEQUENTIAL) && defined(HAVE_POSIX_FADVISE)
229 (void) posix_fadvise(fd
, off
, end
, POSIX_FADV_SEQUENTIAL
);
232 * Dig holes in the area
235 ssize_t rsz
= pread(fd
, buf
, bufsz
, off
);
236 if (rsz
< 0 && errno
)
237 err(EXIT_FAILURE
, _("%s: read failed"), filename
);
238 if (end
&& rsz
> 0 && off
> end
- rsz
)
243 if (is_nul(buf
, rsz
)) {
244 if (!hole_sz
) /* new hole detected */
247 } else if (hole_sz
) {
248 xfallocate(fd
, FALLOC_FL_PUNCH_HOLE
|FALLOC_FL_KEEP_SIZE
,
249 hole_start
, hole_sz
);
251 hole_sz
= hole_start
= 0;
254 #if defined(POSIX_FADV_DONTNEED) && defined(HAVE_POSIX_FADVISE)
255 /* discard cached data */
256 if (off
- cache_start
> (off_t
) cachesz
) {
257 size_t clen
= off
- cache_start
;
259 clen
= (clen
/ cachesz
) * cachesz
;
260 (void) posix_fadvise(fd
, cache_start
, clen
, POSIX_FADV_DONTNEED
);
261 cache_start
= cache_start
+ clen
;
267 off_t alloc_sz
= hole_sz
;
269 alloc_sz
+= st
.st_blksize
; /* meet block boundary */
270 xfallocate(fd
, FALLOC_FL_PUNCH_HOLE
|FALLOC_FL_KEEP_SIZE
,
271 hole_start
, alloc_sz
);
280 char *str
= size_to_human_string(SIZE_SUFFIX_3LETTER
| SIZE_SUFFIX_SPACE
, ct
);
281 fprintf(stdout
, _("%s: %s (%ju bytes) converted to sparse holes.\n"),
287 int main(int argc
, char **argv
)
293 #ifdef HAVE_POSIX_FALLOCATE
296 loff_t length
= -2LL;
299 static const struct option longopts
[] = {
300 { "help", no_argument
, NULL
, 'h' },
301 { "version", no_argument
, NULL
, 'V' },
302 { "keep-size", no_argument
, NULL
, 'n' },
303 { "punch-hole", no_argument
, NULL
, 'p' },
304 { "collapse-range", no_argument
, NULL
, 'c' },
305 { "dig-holes", no_argument
, NULL
, 'd' },
306 { "insert-range", no_argument
, NULL
, 'i' },
307 { "zero-range", no_argument
, NULL
, 'z' },
308 { "offset", required_argument
, NULL
, 'o' },
309 { "length", required_argument
, NULL
, 'l' },
310 { "posix", no_argument
, NULL
, 'x' },
311 { "verbose", no_argument
, NULL
, 'v' },
315 static const ul_excl_t excl
[] = { /* rows and cols in ASCII order */
316 { 'c', 'd', 'p', 'z' },
318 { 'x', 'c', 'd', 'i', 'n', 'p', 'z'},
321 int excl_st
[ARRAY_SIZE(excl
)] = UL_EXCL_STATUS_INIT
;
323 setlocale(LC_ALL
, "");
324 bindtextdomain(PACKAGE
, LOCALEDIR
);
326 close_stdout_atexit();
328 while ((c
= getopt_long(argc
, argv
, "hvVncpdizxl:o:", longopts
, NULL
))
331 err_exclusive_options(c
, longopts
, excl
, excl_st
);
335 mode
|= FALLOC_FL_COLLAPSE_RANGE
;
341 mode
|= FALLOC_FL_INSERT_RANGE
;
344 length
= cvtnum(optarg
);
347 mode
|= FALLOC_FL_KEEP_SIZE
;
350 offset
= cvtnum(optarg
);
353 mode
|= FALLOC_FL_PUNCH_HOLE
| FALLOC_FL_KEEP_SIZE
;
356 mode
|= FALLOC_FL_ZERO_RANGE
;
359 #ifdef HAVE_POSIX_FALLOCATE
363 errx(EXIT_FAILURE
, _("posix_fallocate support is not compiled"));
372 print_version(EXIT_SUCCESS
);
374 errtryhelp(EXIT_FAILURE
);
379 errx(EXIT_FAILURE
, _("no filename specified"));
381 filename
= argv
[optind
++];
384 errx(EXIT_FAILURE
, _("unexpected number of arguments"));
387 /* for --dig-holes the default is analyze all file */
391 errx(EXIT_FAILURE
, _("invalid length value specified"));
393 /* it's safer to require the range specification (--length --offset) */
395 errx(EXIT_FAILURE
, _("no length argument specified"));
397 errx(EXIT_FAILURE
, _("invalid length value specified"));
400 errx(EXIT_FAILURE
, _("invalid offset value specified"));
402 /* O_CREAT makes sense only for the default fallocate(2) behavior
403 * when mode is no specified and new space is allocated */
404 fd
= open(filename
, O_RDWR
| (!dig
&& !mode
? O_CREAT
: 0),
405 S_IRUSR
| S_IWUSR
| S_IRGRP
| S_IWGRP
| S_IROTH
| S_IWOTH
);
407 err(EXIT_FAILURE
, _("cannot open %s"), filename
);
410 dig_holes(fd
, offset
, length
);
412 #ifdef HAVE_POSIX_FALLOCATE
414 xposix_fallocate(fd
, offset
, length
);
417 xfallocate(fd
, mode
, offset
, length
);
420 char *str
= size_to_human_string(SIZE_SUFFIX_3LETTER
| SIZE_SUFFIX_SPACE
, length
);
422 if (mode
& FALLOC_FL_PUNCH_HOLE
)
423 fprintf(stdout
, _("%s: %s (%ju bytes) hole created.\n"),
424 filename
, str
, length
);
425 else if (mode
& FALLOC_FL_COLLAPSE_RANGE
)
426 fprintf(stdout
, _("%s: %s (%ju bytes) removed.\n"),
427 filename
, str
, length
);
428 else if (mode
& FALLOC_FL_INSERT_RANGE
)
429 fprintf(stdout
, _("%s: %s (%ju bytes) inserted.\n"),
430 filename
, str
, length
);
431 else if (mode
& FALLOC_FL_ZERO_RANGE
)
432 fprintf(stdout
, _("%s: %s (%ju bytes) zeroed.\n"),
433 filename
, str
, length
);
435 fprintf(stdout
, _("%s: %s (%ju bytes) allocated.\n"),
436 filename
, str
, length
);
441 if (close_fd(fd
) != 0)
442 err(EXIT_FAILURE
, _("write failed: %s"), filename
);