How to Quickly Create a Large File on Linux

Creating large files efficiently on Linux can be crucial, especially for testing purposes like simulating disk usage or creating virtual machine (VM) images. While tools like dd are commonly used, they can be slow. Here’s a breakdown of faster methods to create large files, avoiding slow disk writes while ensuring the file is allocated on the disk.

1. Using fallocate (Best Choice for Most Cases)

The fallocate command is the fastest way to create large files, as it allocates the required disk space without initializing or writing data. This method ensures that the entire space is reserved without wasting time.

fallocate -l 10G largefile.img

• -l: Defines the length of the file (10 GB in this case).
• Advantages: It’s fast, allocates disk space directly, and doesn’t write any data.
• Limitations: It works only on file systems that support it, such as ext4, xfs, btrfs, and ocfs2.

2. Using dd (Slower but More Universal)

dd is a common utility that copies data from a source (e.g., /dev/zero), filling the file with actual data. However, this can be slow because it writes every block of data, even if it’s just zeroes.

dd if=/dev/zero of=largefile.img bs=1G count=10

• if=/dev/zero: Uses a stream of zeroes as input.
• of=largefile.img: The output file.
• bs=1G: Block size (1 GB).
• count=10: Number of blocks (10 blocks of 1 GB each).
• Disadvantages: This method is slower as it writes every block of data to the file.

3. Using truncate (Creates Sparse Files, but Not Always Suitable)

truncate is another fast method, but it creates a sparse file, which means the file doesn’t actually use all the disk space unless data is written to it. This makes it unsuitable if you require the file to actually allocate disk space.

truncate -s 10G largefile.img

• -s: Sets the size of the file.
• Sparse File: The file “pretends” to take up 10 GB, but disk space is not actually allocated unless data is written to it.
• Limitations: Not usable if you need the file to fully allocate the disk space for testing purposes.

4. Using xfs_mkfile (For XFS and Other Filesystems)

For systems with XFS or similar file systems, xfs_mkfile can be used to create large files efficiently.

xfs_mkfile 10G largefile.img

• This tool works similarly to fallocate, ensuring the disk space is allocated.
• Available in xfsprogs package.

5. Using mkfile on Other UNIX-Like Systems

On other UNIX systems like Solaris, HP-UX, and macOS, you can use the mkfile command.

mkfile 10G largefile.img

• Note: This is not available on Linux by default, but it works similarly to fallocate or xfs_mkfile.

Summary of Methods

Method	Speed	File System Support	Notes
fallocate	Fastest	ext4, xfs, btrfs, ocfs2	Best option if supported; does not write data.
dd	Slow	All	Writes data to disk; slow but works universally.
truncate	Fast (Sparse)	All	Creates sparse files; disk space not fully allocated.
xfs_mkfile	Fast	XFS and others	Works on multiple file systems, fast like fallocate.
mkfile	Fast	macOS, Solaris, HP-UX	Similar to fallocate but for non-Linux systems.

For most modern Linux systems, fallocate is the fastest and most efficient way to create a large file. If you’re working with file systems that don’t support fallocate, you may fall back on dd, though it’s significantly slower due to the need to write data. For systems outside Linux, tools like mkfile offer similar functionality.