The easiest way to work with i-node flags is via shell commands:

# View current flags on a file
$ lsattr myfile
--------------e---- myfile     (e = uses extents, default on ext4)

# Set a flag using chattr (+flag adds, -flag removes, =flag sets exactly)
$ chattr +i myfile             # Make immutable
$ lsattr myfile
----i---------e---- myfile

# Try to delete it — even root fails!
$ rm myfile
rm: cannot remove 'myfile': Operation not permitted

# Remove immutable flag first
$ chattr -i myfile
$ rm myfile                    # Now it works

# Set append-only (useful for log files)
$ chattr +a /var/log/myapp.log
# Now: open(log, O_WRONLY) fails, but open(log, O_WRONLY|O_APPEND) succeeds

# Set both append-only and immutable
$ chattr +ai myfile

# Skip atime updates for performance
$ chattr +A myfile

# Apply flags recursively to a directory tree
$ chattr -R +A /var/www/html   # Skip atime on all web files

From C programs, use ioctl() with FS_IOC_GETFLAGS and FS_IOC_SETFLAGS:

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <linux/fs.h>   /* FS_IOC_GETFLAGS, FS_IOC_SETFLAGS, FS_*_FL */
#include <stdlib.h>

Example 1: Read current i-node flags

int get_inode_flags(const char *path) {
    int fd, flags;

    fd = open(path, O_RDONLY);
    if (fd == -1) { perror("open"); return -1; }

    if (ioctl(fd, FS_IOC_GETFLAGS, &flags) == -1) {
        perror("ioctl GETFLAGS");
        close(fd);
        return -1;
    }
    close(fd);
    return flags;
}

int main(void) {
    int flags = get_inode_flags("myfile");
    if (flags == -1) return 1;

    printf("Flags: 0x%x\n", flags);
    if (flags & FS_IMMUTABLE_FL)    printf("  Immutable (i)\n");
    if (flags & FS_APPEND_FL)       printf("  Append-only (a)\n");
    if (flags & FS_NOATIME_FL)      printf("  No-atime (A)\n");
    if (flags & FS_SYNC_FL)         printf("  Sync (S)\n");
    if (flags & FS_NODUMP_FL)       printf("  No-dump (d)\n");
    if (flags & FS_JOURNAL_DATA_FL) printf("  Journal data (j)\n");

    return 0;
}

Example 2: Set the FS_NOATIME_FL flag (skip atime updates)

int set_noatime_flag(const char *path) {
    int fd, flags;

    /* Must open with write access to set flags (or be owner/root) */
    fd = open(path, O_RDONLY);
    if (fd == -1) { perror("open"); return -1; }

    /* Step 1: Get current flags */
    if (ioctl(fd, FS_IOC_GETFLAGS, &flags) == -1) {
        perror("ioctl GETFLAGS");
        close(fd);
        return -1;
    }

    /* Step 2: Add the flag using OR */
    flags |= FS_NOATIME_FL;

    /* Step 3: Set the updated flags */
    if (ioctl(fd, FS_IOC_SETFLAGS, &flags) == -1) {
        perror("ioctl SETFLAGS");
        close(fd);
        return -1;
    }

    printf("FS_NOATIME_FL set on %s\n", path);
    close(fd);
    return 0;
}

int main(void) {
    return set_noatime_flag("myfile");
}

Example 3: Clear (remove) a specific flag

int clear_flag(const char *path, int flag_to_clear) {
    int fd, flags;

    fd = open(path, O_RDONLY);
    if (fd == -1) { perror("open"); return -1; }

    if (ioctl(fd, FS_IOC_GETFLAGS, &flags) == -1) {
        close(fd); return -1;
    }

    /* Remove the flag using AND NOT */
    flags &= ~flag_to_clear;

    if (ioctl(fd, FS_IOC_SETFLAGS, &flags) == -1) {
        close(fd); return -1;
    }

    close(fd);
    return 0;
}

int main(void) {
    /* Remove noatime flag */
    if (clear_flag("myfile", FS_NOATIME_FL) == 0)
        printf("Cleared FS_NOATIME_FL\n");
    return 0;
}

Example 4: Make a file immutable (needs CAP_LINUX_IMMUTABLE / root)

/* WARNING: Run as root. Once immutable, even root cannot modify/delete.
   Must clear immutable flag first to make any changes. */

int make_immutable(const char *path) {
    int fd, flags;

    fd = open(path, O_RDONLY);
    if (fd == -1) { perror("open"); return -1; }

    if (ioctl(fd, FS_IOC_GETFLAGS, &flags) == -1) {
        close(fd); return -1;
    }

    flags |= FS_IMMUTABLE_FL;

    if (ioctl(fd, FS_IOC_SETFLAGS, &flags) == -1) {
        perror("ioctl SETFLAGS (need root and CAP_LINUX_IMMUTABLE)");
        close(fd);
        return -1;
    }

    printf("File is now immutable. Cannot be changed or deleted.\n");
    close(fd);
    return 0;
}

/* To reverse it: clear_flag(path, FS_IMMUTABLE_FL)
   Use case: protect critical system config files from accidental deletion
   e.g. make_immutable("/etc/hosts");  */

Example 5: Set append-only on a log file

/* Append-only: processes can only add data, never overwrite.
   Good for log files — even if program is compromised, it can't
   falsify old log entries. */

int make_append_only(const char *path) {
    int fd, flags;

    fd = open(path, O_RDONLY);
    if (fd == -1) { perror("open"); return -1; }

    if (ioctl(fd, FS_IOC_GETFLAGS, &flags) == -1) {
        close(fd); return -1;
    }

    flags |= FS_APPEND_FL;

    if (ioctl(fd, FS_IOC_SETFLAGS, &flags) == -1) {
        perror("ioctl (need root)");
        close(fd); return -1;
    }

    printf("Log file is now append-only\n");
    close(fd);
    return 0;
}

/* After this:
   open(path, O_WRONLY)         → EPERM
   open(path, O_WRONLY|O_APPEND) → OK
   write(fd, ...)               → data appended to end only */

Example 6: Utility — print all set flags as a string

#include <stdio.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/fs.h>

struct { int flag; char letter; } flag_map[] = {
    { FS_APPEND_FL,      'a' },
    { FS_NODUMP_FL,      'd' },
    { FS_IMMUTABLE_FL,   'i' },
    { FS_JOURNAL_DATA_FL,'j' },
    { FS_NOATIME_FL,     'A' },
    { FS_SYNC_FL,        'S' },
    { FS_DIRSYNC_FL,     'D' },
    { FS_NOTAIL_FL,      't' },
    { FS_TOPDIR_FL,      'T' },
    { 0, 0 }
};

void lsattr_for_file(const char *path) {
    int fd, flags, i;
    char flag_str[20] = "-------------";  /* 13 dashes = no flags */

    fd = open(path, O_RDONLY);
    if (fd == -1) { perror("open"); return; }

    if (ioctl(fd, FS_IOC_GETFLAGS, &flags) == 0) {
        for (i = 0; flag_map[i].flag; i++) {
            if (flags & flag_map[i].flag)
                flag_str[i] = flag_map[i].letter;
        }
        printf("%s  %s\n", flag_str, path);
    }
    close(fd);
}

int main(int argc, char *argv[]) {
    if (argc < 2) { fprintf(stderr, "Usage: %s file...\n", argv[0]); return 1; }
    for (int i = 1; i < argc; i++)
        lsattr_for_file(argv[i]);
    return 0;
}

When you set i-node flags on a directory, those flags are generally inherited by new files and subdirectories created inside. But there are exceptions: