All three are stored as seconds since the Epoch (1 January 1970, 00:00:00 UTC).

Which timestamps change for each operation?

The kernel normally updates timestamps automatically. But you can manually set them using these APIs. Tools like tar and unzip use these to restore original timestamps when extracting archives.

Example 1: Read and print all three timestamps

#include <stdio.h>
#include <sys/stat.h>
#include <time.h>
#include <stdlib.h>

int main(int argc, char *argv[]) {
    struct stat sb;
    if (argc != 2) { fprintf(stderr, "Usage: %s file\n", argv[0]); exit(1); }

    if (stat(argv[1], &sb) == -1) { perror("stat"); exit(1); }

    /* ctime() converts time_t to human-readable string */
    printf("Last access   (atime): %s", ctime(&sb.st_atime));
    printf("Last modified (mtime): %s", ctime(&sb.st_mtime));
    printf("Last i-node chg(ctime): %s", ctime(&sb.st_ctime));

    /* Raw seconds since epoch */
    printf("\nRaw mtime (epoch secs): %ld\n", (long)sb.st_mtime);

    return 0;
}
/* Try: touch testfile; ./timestamps testfile; cat testfile; ./timestamps testfile
   Notice how atime changes after cat (read), mtime does not */

Example 2: utime() — set timestamps in seconds precision

#include <stdio.h>
#include <utime.h>
#include <sys/stat.h>
#include <stdlib.h>

int main(void) {
    struct utimbuf utb;
    struct stat sb;

    /* Case 1: Pass NULL — sets both atime and mtime to current time */
    if (utime("testfile", NULL) == -1) {
        perror("utime");
        exit(1);
    }
    printf("Reset both timestamps to NOW\n");

    /* Case 2: Set to specific values */
    /* Set mtime to same as atime (leave atime unchanged) */
    if (stat("testfile", &sb) == -1) { perror("stat"); exit(1); }

    utb.actime  = sb.st_atime;  /* keep atime unchanged */
    utb.modtime = sb.st_atime;  /* set mtime = atime */

    if (utime("testfile", &utb) == -1) {
        perror("utime");
        exit(1);
    }
    printf("Set mtime = atime\n");

    /* Note: utime() always sets ctime to current time */
    return 0;
}

Example 3: utimes() — microsecond precision

#include <stdio.h>
#include <sys/time.h>
#include <stdlib.h>

int main(void) {
    struct timeval tv[2];

    /* tv[0] = new atime, tv[1] = new mtime */
    /* Set atime to a fixed point: 2024-01-01 00:00:00 UTC */
    tv[0].tv_sec  = 1704067200;  /* seconds since epoch */
    tv[0].tv_usec = 500000;      /* + 500ms (microseconds) */

    /* Set mtime to current time */
    gettimeofday(&tv[1], NULL);  /* fill with current time */

    if (utimes("testfile", tv) == -1) {
        perror("utimes");
        exit(1);
    }
    printf("Timestamps updated with microsecond precision\n");

    /* Pass NULL to set both to current time (same as utime with NULL) */
    utimes("testfile", NULL);

    return 0;
}

Example 4: utimensat() — nanosecond precision (modern, recommended)

#define _XOPEN_SOURCE 700
#include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>

int main(void) {
    struct timespec times[2];

    /* Example A: Set BOTH timestamps to current time */
    times[0].tv_sec  = 0;
    times[0].tv_nsec = UTIME_NOW;   /* special value: use current time */
    times[1].tv_sec  = 0;
    times[1].tv_nsec = UTIME_NOW;

    if (utimensat(AT_FDCWD, "testfile", times, 0) == -1) {
        perror("utimensat");
        exit(1);
    }
    printf("Both timestamps set to NOW\n");

    /* Example B: Set atime to now, leave mtime unchanged */
    times[0].tv_nsec = UTIME_NOW;   /* atime = now */
    times[1].tv_nsec = UTIME_OMIT;  /* mtime = leave as-is */

    utimensat(AT_FDCWD, "testfile", times, 0);
    printf("atime updated, mtime untouched\n");

    /* Example C: Set a specific nanosecond timestamp */
    times[0].tv_sec  = 1704067200;   /* seconds */
    times[0].tv_nsec = 123456789;    /* nanoseconds */
    times[1].tv_nsec = UTIME_OMIT;   /* leave mtime alone */

    utimensat(AT_FDCWD, "testfile", times, 0);
    printf("atime set to specific nanosecond value\n");

    /* Example D: Change symlink's own timestamps (not target) */
    utimensat(AT_FDCWD, "mylink", times, AT_SYMLINK_NOFOLLOW);

    return 0;
}

Example 5: futimens() — update timestamps via file descriptor

#define _GNU_SOURCE
#include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>

int main(void) {
    int fd;
    struct timespec times[2];

    fd = open("testfile", O_RDWR);
    if (fd == -1) { perror("open"); exit(1); }

    times[0].tv_nsec = UTIME_NOW;   /* atime = now */
    times[1].tv_nsec = UTIME_NOW;   /* mtime = now */

    /* Uses fd, not pathname — race-condition-safe */
    if (futimens(fd, times) == -1) {
        perror("futimens");
    }

    close(fd);
    return 0;
}

Example 6: Compare two files by mtime (like make does)

#include <stdio.h>
#include <sys/stat.h>

/* Returns 1 if src is newer than dst (src_mtime > dst_mtime) */
int is_newer(const char *src, const char *dst) {
    struct stat s_src, s_dst;

    if (stat(src, &s_src) == -1) return 0;
    if (stat(dst, &s_dst) == -1) return 1; /* dst doesn't exist = rebuild */

    return s_src.st_mtime > s_dst.st_mtime;
}

int main(void) {
    /* Simulate what make(1) does */
    if (is_newer("main.c", "main.o")) {
        printf("main.c is newer — recompile needed\n");
    } else {
        printf("main.o is up to date\n");
    }
    return 0;
}

Example 7: Nanosecond timestamps (Linux 2.6+ with glibc 2.3+)

#include <stdio.h>
#include <sys/stat.h>

int main(void) {
    struct stat sb;
    stat("testfile", &sb);

    /* Traditional field: seconds only */
    printf("mtime seconds: %ld\n", (long)sb.st_mtime);

    /* Nanosecond field (glibc 2.3+, Linux 2.6+):
       st_mtim is a struct timespec inside stat
       Access nanoseconds via .tv_nsec */
    printf("mtime nanoseconds: %ld\n", sb.st_mtim.tv_nsec);
    printf("atime nanoseconds: %ld\n", sb.st_atim.tv_nsec);
    printf("ctime nanoseconds: %ld\n", sb.st_ctim.tv_nsec);

    /* Not all filesystems support nanoseconds:
       ext4, XFS, Btrfs, JFS — YES
       ext2, ext3, Reiserfs  — NO  */
    return 0;
}