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 printf(USAGE_HELP_OPTIONS(22));
106 printf(USAGE_MAN_TAIL("fallocate(1)"));
111 static loff_t
cvtnum(char *s
)
115 if (strtosize(s
, &x
))
121 static void xfallocate(int fd
, int mode
, off_t offset
, off_t length
)
125 #ifdef HAVE_FALLOCATE
126 error
= fallocate(fd
, mode
, offset
, length
);
128 error
= syscall(SYS_fallocate
, fd
, mode
, offset
, length
);
131 * EOPNOTSUPP: The FALLOC_FL_KEEP_SIZE is unsupported
132 * ENOSYS: The filesystem does not support sys_fallocate
135 if ((mode
& FALLOC_FL_KEEP_SIZE
) && errno
== EOPNOTSUPP
)
136 errx(EXIT_FAILURE
, _("fallocate failed: keep size mode is unsupported"));
137 err(EXIT_FAILURE
, _("fallocate failed"));
141 #ifdef HAVE_POSIX_FALLOCATE
142 static void xposix_fallocate(int fd
, off_t offset
, off_t length
)
144 int error
= posix_fallocate(fd
, offset
, length
);
146 err(EXIT_FAILURE
, _("fallocate failed"));
151 /* The real buffer size has to be bufsize + sizeof(uintptr_t) */
152 static int is_nul(void *buf
, size_t bufsize
)
154 typedef uintptr_t word
;
156 char const *cbuf
= buf
, *cp
;
157 word
const *wp
= buf
;
160 memset((char *) buf
+ bufsize
, '\1', sizeof(word
));
162 /* Find first nonzero *word*, or the word with the sentinel. */
166 /* Find the first nonzero *byte*, or the sentinel. */
173 return cbuf
+ bufsize
< cp
;
176 static void dig_holes(int fd
, off_t file_off
, off_t len
)
178 off_t file_end
= len
? file_off
+ len
: 0;
179 off_t hole_start
= 0, hole_sz
= 0;
184 #if defined(POSIX_FADV_SEQUENTIAL) && defined(HAVE_POSIX_FADVISE)
185 off_t cache_start
= file_off
;
187 * We don't want to call POSIX_FADV_DONTNEED to discard cached
188 * data in PAGE_SIZE steps. IMHO it's overkill (too many syscalls).
190 * Let's assume that 1MiB (on system with 4K page size) is just
194 const size_t cachesz
= getpagesize() * 256;
197 if (fstat(fd
, &st
) != 0)
198 err(EXIT_FAILURE
, _("stat of %s failed"), filename
);
200 bufsz
= st
.st_blksize
;
202 if (lseek(fd
, file_off
, SEEK_SET
) < 0)
203 err(EXIT_FAILURE
, _("seek on %s failed"), filename
);
205 /* buffer + extra space for is_nul() sentinel */
206 buf
= xmalloc(bufsz
+ sizeof(uintptr_t));
207 while (file_end
== 0 || file_off
< file_end
) {
209 * Detect data area (skip holes)
213 off
= lseek(fd
, file_off
, SEEK_DATA
);
214 if ((off
== -1 && errno
== ENXIO
) ||
215 (file_end
&& off
>= file_end
))
218 end
= lseek(fd
, off
, SEEK_HOLE
);
219 if (file_end
&& end
> file_end
)
222 #if defined(POSIX_FADV_SEQUENTIAL) && defined(HAVE_POSIX_FADVISE)
223 posix_fadvise(fd
, off
, end
, POSIX_FADV_SEQUENTIAL
);
226 * Dig holes in the area
229 ssize_t rsz
= pread(fd
, buf
, bufsz
, off
);
230 if (rsz
< 0 && errno
)
231 err(EXIT_FAILURE
, _("%s: read failed"), filename
);
232 if (end
&& rsz
> 0 && off
> end
- rsz
)
237 if (is_nul(buf
, rsz
)) {
238 if (!hole_sz
) /* new hole detected */
241 } else if (hole_sz
) {
242 xfallocate(fd
, FALLOC_FL_PUNCH_HOLE
|FALLOC_FL_KEEP_SIZE
,
243 hole_start
, hole_sz
);
245 hole_sz
= hole_start
= 0;
248 #if defined(POSIX_FADV_DONTNEED) && defined(HAVE_POSIX_FADVISE)
249 /* discard cached data */
250 if (off
- cache_start
> (off_t
) cachesz
) {
251 size_t clen
= off
- cache_start
;
253 clen
= (clen
/ cachesz
) * cachesz
;
254 posix_fadvise(fd
, cache_start
, clen
, POSIX_FADV_DONTNEED
);
255 cache_start
= cache_start
+ clen
;
261 xfallocate(fd
, FALLOC_FL_PUNCH_HOLE
|FALLOC_FL_KEEP_SIZE
,
262 hole_start
, hole_sz
);
271 char *str
= size_to_human_string(SIZE_SUFFIX_3LETTER
| SIZE_SUFFIX_SPACE
, ct
);
272 fprintf(stdout
, _("%s: %s (%ju bytes) converted to sparse holes.\n"),
278 int main(int argc
, char **argv
)
285 loff_t length
= -2LL;
288 static const struct option longopts
[] = {
289 { "help", no_argument
, NULL
, 'h' },
290 { "version", no_argument
, NULL
, 'V' },
291 { "keep-size", no_argument
, NULL
, 'n' },
292 { "punch-hole", no_argument
, NULL
, 'p' },
293 { "collapse-range", no_argument
, NULL
, 'c' },
294 { "dig-holes", no_argument
, NULL
, 'd' },
295 { "insert-range", no_argument
, NULL
, 'i' },
296 { "zero-range", no_argument
, NULL
, 'z' },
297 { "offset", required_argument
, NULL
, 'o' },
298 { "length", required_argument
, NULL
, 'l' },
299 { "posix", no_argument
, NULL
, 'x' },
300 { "verbose", no_argument
, NULL
, 'v' },
304 static const ul_excl_t excl
[] = { /* rows and cols in ASCII order */
305 { 'c', 'd', 'p', 'z' },
307 { 'x', 'c', 'd', 'i', 'n', 'p', 'z'},
310 int excl_st
[ARRAY_SIZE(excl
)] = UL_EXCL_STATUS_INIT
;
312 setlocale(LC_ALL
, "");
313 bindtextdomain(PACKAGE
, LOCALEDIR
);
315 atexit(close_stdout
);
317 while ((c
= getopt_long(argc
, argv
, "hvVncpdizxl:o:", longopts
, NULL
))
320 err_exclusive_options(c
, longopts
, excl
, excl_st
);
327 mode
|= FALLOC_FL_COLLAPSE_RANGE
;
333 mode
|= FALLOC_FL_INSERT_RANGE
;
336 length
= cvtnum(optarg
);
339 mode
|= FALLOC_FL_KEEP_SIZE
;
342 offset
= cvtnum(optarg
);
345 mode
|= FALLOC_FL_PUNCH_HOLE
| FALLOC_FL_KEEP_SIZE
;
348 mode
|= FALLOC_FL_ZERO_RANGE
;
351 #ifdef HAVE_POSIX_FALLOCATE
355 errx(EXIT_FAILURE
, _("posix_fallocate support is not compiled"));
361 printf(UTIL_LINUX_VERSION
);
364 errtryhelp(EXIT_FAILURE
);
369 errx(EXIT_FAILURE
, _("no filename specified"));
371 filename
= argv
[optind
++];
374 errx(EXIT_FAILURE
, _("unexpected number of arguments"));
377 /* for --dig-holes the default is analyze all file */
381 errx(EXIT_FAILURE
, _("invalid length value specified"));
383 /* it's safer to require the range specification (--length --offset) */
385 errx(EXIT_FAILURE
, _("no length argument specified"));
387 errx(EXIT_FAILURE
, _("invalid length value specified"));
390 errx(EXIT_FAILURE
, _("invalid offset value specified"));
392 /* O_CREAT makes sense only for the default fallocate(2) behavior
393 * when mode is no specified and new space is allocated */
394 fd
= open(filename
, O_RDWR
| (!dig
&& !mode
? O_CREAT
: 0),
395 S_IRUSR
| S_IWUSR
| S_IRGRP
| S_IWGRP
| S_IROTH
| S_IWOTH
);
397 err(EXIT_FAILURE
, _("cannot open %s"), filename
);
400 dig_holes(fd
, offset
, length
);
401 #ifdef HAVE_POSIX_FALLOCATE
403 xposix_fallocate(fd
, offset
, length
);
406 xfallocate(fd
, mode
, offset
, length
);
408 if (close_fd(fd
) != 0)
409 err(EXIT_FAILURE
, _("write failed: %s"), filename
);