Wie erstelle ich eine Datei mit Dateilöchern?

Dateilöcher sind die leeren Stellen in der Datei, die jedoch keinen Speicherplatz belegen und Nullbytes enthalten. Daher ist die Dateigröße größer als die tatsächliche Größe auf der Festplatte.

Ich weiß jedoch nicht, wie ich eine Datei mit Dateilöchern zum Experimentieren erstellen kann.

Verwenden Sie die dd Befehl mit a seek Parameter.

dd if=/dev/urandom bs=4096 count=2 of=file_with_holes
dd if=/dev/urandom bs=4096 seek=7 count=2 of=file_with_holes

Das erzeugt für Sie eine Datei mit einem schönen Loch von Byte 8192 bis Byte 28671.

Hier ist ein Beispiel, das zeigt, dass die Datei tatsächlich Löcher enthält (die ls -s Befehl sagt Ihnen, wie viele Festplattenblöcke von einer Datei verwendet werden):

$ dd if=/dev/urandom bs=4096 count=2 of=fwh # fwh = file with holes
2+0 records in
2+0 records out
8192 bytes (8.2 kB) copied, 0.00195565 s, 4.2 MB/s

$ dd if=/dev/urandom seek=7 bs=4096 count=2 of=fwh
2+0 records in
2+0 records out
8192 bytes (8.2 kB) copied, 0.00152742 s, 5.4 MB/s

$ dd if=/dev/zero bs=4096 count=9 of=fwnh # fwnh = file with no holes
9+0 records in
9+0 records out
36864 bytes (37 kB) copied, 0.000510568 s, 72.2 MB/s

$ ls -ls fw*
16 -rw-rw-r-- 1 hopper hopper 36864 Mar 15 10:25 fwh
36 -rw-rw-r-- 1 hopper hopper 36864 Mar 15 10:29 fwnh

Wie Sie sehen können, nimmt die Datei mit Löchern trotz gleicher Größe weniger Festplattenblöcke ein.

Wenn Sie ein Programm suchen, das dies tut, hier ist es:

#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
#include <fcntl.h>

int main(int argc, const char *argv[])
{
    char random_garbage[8192]; /* Don't even bother to initialize */
    int fd = -1;
    if (argc < 2) {
        fprintf(stderr, "Usage: %s <filename>\n", argv[0]);
        return 1;
    }
    fd = open(argv[1], O_WRONLY | O_CREAT | O_TRUNC, 0666);
    if (fd < 0) {
        perror("Can't open file: ");
        return 2;
    }
    write(fd, random_garbage, 8192);
    lseek(fd, 5 * 4096, SEEK_CUR);
    write(fd, random_garbage, 8192);
    close(fd);
    return 0;
}

Das obige sollte auf jedem Unix funktionieren. Jemand anderes antwortete mit einer netten alternativen Methode, die sehr Linux-spezifisch ist. Ich hebe es hier hervor, weil es eine Methode ist, die sich von den beiden, die ich gegeben habe, unterscheidet und verwendet werden kann, um Löcher in vorhandene Dateien zu setzen.

1. Erstellen Sie eine Datei.
2. Position suchen N.
3. Schreiben Sie einige Daten.

Es wird ein Loch am Anfang der Datei geben (bis zu und ohne position N). Sie können auf ähnliche Weise Dateien mit Löchern in der Mitte erstellen.

Das folgende Dokument enthält einen Beispiel-C-Code (suchen Sie nach “Sparse-Dateien”): http://www.win.tue.nl/~aeb/linux/lk/lk-6.html

Abgesehen davon, dass Sie Dateien mit Löchern erstellen können, können Sie seit ~2 Monaten (Mitte Januar 2011) Löcher in bestehende Dateien unter Linux stanzen, indem Sie verwenden fallocate(2) FALLOC_FL_PUNCH_HOLE LWN-Artikel, git commit auf Linus’ Baum, Patch auf die Manpages von Linux.

Das Problem wird ausführlich in Abschnitt 3.6 von W.Richard Stevens berühmtem Buch „Advanced Programming in the UNIX Environment“ (kurz APUE) diskutiert. Hier wird die in unistd.h enthaltene lseek-Funktion verwendet, die dazu dient, den Offset einer geöffneten Datei explizit zu setzen. Der Prototyp der lseek-Funktion sieht wie folgt aus:

off_t lseek(int filedes, off_t offset, int whence);

Hier ist filedes der Dateideskriptor, offset ist der Wert, den wir setzen möchten, und wherece ist eine Konstante, die in der Header-Datei festgelegt ist, insbesondere SEEK_SET, was bedeutet, dass der Offset vom Anfang der Datei an gesetzt wird; SEEK_CUR, was bedeutet, dass der Offset auf seinen aktuellen Wert plus den Offset in der Argumentliste gesetzt wird; SEEK_END, was bedeutet, dass der Offset der Datei auf die Größe der Datei plus den Offset in der Argumentliste gesetzt wird.

Das Beispiel zum Erstellen einer Datei mit Löchern in C unter UNIX-ähnlichen Betriebssystemen lautet wie folgt:

/*Creating a file with a hole of size 810*/
#include <fcntl.h>

/*Two strings to write to the file*/    
char buf1[] = "abcde";
char buf2[] = "ABCDE";

int main()
{
    int fd; /*file descriptor*/

    if((fd = creat("file_with_hole", FILE_MODE)) < 0)
        err_sys("creat error");
    if(write(fd, buf1, 5) != 5)
        err_sys("buf1 write error");
    /*offset now 5*/

    if(lseek(fd, 815, SEEK_SET) == -1)
        err_sys("lseek error");
    /*offset now 815*/

    if(write(fd, buf2, 5) !=5)
        err_sys("buf2 write error");
    /*offset now 820*/

    return 0;
}

Im obigen Code ist err_sys die Funktion zur Behandlung schwerwiegender Fehler im Zusammenhang mit einem Systemaufruf.

Ein Loch entsteht, wenn Daten mit einem Offset geschrieben werden, der über die aktuelle Dateigröße hinausgeht, oder wenn die Dateigröße auf etwas größer als die aktuelle Dateigröße gekürzt wird