std.inotify

Dateisystem-Ereignisüberwachung via Linux inotify (WP-10). Meldet Datei- und Verzeichnisänderungen ohne Polling: Ein inotify-fd liefert via InotifyRead eine Folge von inotify_event-Einträgen. Mehrere Pfade können über separate Watch-Deskriptoren (wd) an einen einzigen fd gehängt werden.

→ Standard Library · std.fs · std.fs_ext

Jedes von InotifyRead gelieferte Ereignis hat folgenden Aufbau im Puffer:

INOTIFY_EVENT_HDR_SIZE (16) ist die feste Header-Größe ohne name.

import std.inotify;
import std.alloc;
import std.io;

fn WatchDir(path: pchar): void {
    var fd := InotifyCreate();
    var wd := InotifyWatch(fd, path, IN_CREATE | IN_DELETE | IN_MODIFY);

    var buf: int64 := alloc(4096);

    var running: bool := true;
    while (running) {
        var n := InotifyRead(fd, buf, 4096);
        if (n < 0) { running := false; }

        var ptr := buf;
        while (ptr < buf + n) {
            var mask := InotifyEventMask(ptr);
            var name := InotifyEventName(ptr);

            if ((mask & IN_CREATE) != 0) {
                PrintLn("Erstellt: " + name);
            }
            if ((mask & IN_DELETE) != 0) {
                PrintLn("Gelöscht: " + name);
            }
            if ((mask & IN_MODIFY) != 0) {
                PrintLn("Geändert: " + name);
            }
            if ((mask & IN_ISDIR) != 0) {
                PrintLn("  (Verzeichnis)");
            }

            ptr := InotifyEventNext(ptr);
        }
    }

    free(buf, 4096);
    InotifyUnwatch(fd, wd);
    close(fd);
}

import std.inotify;
import std.alloc;
import std.io;

fn WatchMultiple(): void {
    var fd := InotifyCreate();

    // Verschiedene Verzeichnisse mit unterschiedlichen Masken
    var wd1 := InotifyWatch(fd, "/etc",     IN_MODIFY | IN_CREATE);
    var wd2 := InotifyWatch(fd, "/var/log", IN_MODIFY);
    var wd3 := InotifyWatch(fd, "/tmp",     IN_ALL_EVENTS);

    var buf: int64 := alloc(8192);
    var n := InotifyRead(fd, buf, 8192);

    var ptr := buf;
    while (ptr < buf + n) {
        var wd   := InotifyEventWd(ptr);
        var mask := InotifyEventMask(ptr);
        var name := InotifyEventName(ptr);

        PrintLn("wd=" + IntToStr(wd) + " mask=" + IntToStr(mask) + " name=" + name);

        ptr := InotifyEventNext(ptr);
    }

    free(buf, 8192);
    close(fd);
}

import std.inotify;
import std.alloc;

// Wartet auf die erste Änderung einer Datei, dann Schluss.
fn WaitForChange(path: pchar): void {
    var fd := InotifyCreate();
    InotifyWatch(fd, path, IN_MODIFY | IN_ONESHOT);

    var buf: int64 := alloc(128);
    InotifyRead(fd, buf, 128);   // blockiert bis zum ersten Event
    free(buf, 128);
    close(fd);
}

IN_MOVED_FROM und IN_MOVED_TO haben denselben cookie-Wert und können so als zusammengehörendes Rename/Move-Paar erkannt werden.

import std.inotify;
import std.alloc;
import std.io;

fn TrackMoves(dir: pchar): void {
    var fd := InotifyCreate();
    InotifyWatch(fd, dir, IN_MOVED_FROM | IN_MOVED_TO);

    var buf: int64 := alloc(4096);
    var n   := InotifyRead(fd, buf, 4096);
    var ptr := buf;
    while (ptr < buf + n) {
        var mask   := InotifyEventMask(ptr);
        var cookie := InotifyEventCookie(ptr);
        var name   := InotifyEventName(ptr);

        if ((mask & IN_MOVED_FROM) != 0) {
            PrintLn("Quelle (cookie=" + IntToStr(cookie) + "): " + name);
        }
        if ((mask & IN_MOVED_TO) != 0) {
            PrintLn("Ziel   (cookie=" + IntToStr(cookie) + "): " + name);
        }
        ptr := InotifyEventNext(ptr);
    }
    free(buf, 4096);
    close(fd);
}

• Der inotify-fd kann zusammen mit std.net.epoll in eine epoll-Instanz eingehängt werden, um Dateisystemereignisse und Netzwerkereignisse in derselben Event-Loop zu verarbeiten.
• Bei rekursiver Verzeichnisüberwachung muss jedes Unterverzeichnis einzeln per InotifyWatch registriert werden — inotify ist nicht rekursiv.
• IN_Q_OVERFLOW signalisiert, dass Events verloren gingen. Puffergröße erhöhen oder Lese-Rate steigern.
• InotifyEventLen kann 0 sein, wenn das Ereignis kein name-Feld hat (z. B. IN_DELETE_SELF).

• std.fs — Datei-I/O
• std.fs_ext — Erweitertes Datei-I/O (pread, sendfile …)
• std.net.epoll — Event-Loop-Integration
• std.signals — UNIX-Signalbehandlung

Letzte Aktualisierung: 2026-06-05