What is the access time in Unix

Question

I want to know what access time is. I searched in the web but got the same definition:

read - gets changed

I know with touch we can change it. Could anyone explain me more about it with an example how it is changed? And is there a way to get the creating date/time in unix?

Answer 1

Last access time

• Time when file data last accessed.
• Changed by the mknod(2), utimes(2) and read(2) system calls.

Last modified time

• Time when file data last modified.
• Changed by the mknod(2), utimes(2) and write(2) system calls.

Last changed time

• Time when file status was last changed (inode data modification).
• Changed by the chmod(2), chown(2), link(2), mknod(2), rename(2), unlink(2), utimes(2) and write(2) system calls.

Answer 2

the average time between a request for information stored in a particular component such as the hard derive or RAM and it's delivery. On the other word time between when a read request and when the desired word comes. For example 235,288 units/ 13,82 transactions = 16.8 units per transaction.

Answer 3

Contrary to an above answer, the creation or actually "birth" date is stored and can be accessed, see https://unix.stackexchange.com/a/50184/8250 (the debugfs should be done under sudo)

Answer 4

stat structure

The stat(2) structure keeps track of all the file date/times:

struct stat {
    dev_t     st_dev;     /* ID of device containing file */
    ino_t     st_ino;     /* inode number */
    mode_t    st_mode;    /* protection */
    nlink_t   st_nlink;   /* number of hard links */
    uid_t     st_uid;     /* user ID of owner */
    gid_t     st_gid;     /* group ID of owner */
    dev_t     st_rdev;    /* device ID (if special file) */
    off_t     st_size;    /* total size, in bytes */
    blksize_t st_blksize; /* blocksize for file system I/O */
    blkcnt_t  st_blocks;  /* number of 512B blocks allocated */
    time_t    st_atime;   /* time of last access */
    time_t    st_mtime;   /* time of last modification */
    time_t    st_ctime;   /* time of last status change */
};

st_atime is the access time, updated on read(2) calls (and probably also when open(2) opens a file for reading) — it is NOT updated when files are read via mmap(2). (Which is why I assume open(2) will mark the access time.)

st_mtime is the data modification time, either via write(2) or truncate(2) or open(2) for writing. (Again, it is NOT updated when files are written via mmap(2).)

st_ctime is the metadata modification time: when any of the other data in the struct stat gets modified.

Changing timestamps

You can change the timestamps on files with utime(2):

struct utimbuf {
    time_t actime;       /* access time */
    time_t modtime;      /* modification time */
};

Note you can only change the access time and (data) modification time. You can set either of these to arbitrary times, but the ctime is going to be set to the current time — because you changed the metadata for the file.

stat structure does not have create time

There is no create time in this structure, so it's not possible to find out when a file was created directly from the system.

If you really need to know the create time, you can narrow it down to a range by looking at your backups — assuming the file you're interested in has been backed up, along with its metadata.

statx structure does have create time

The statx(2) syscall introduced a new structure that can report the creation time of a file. Not all filesystems support this feature.

struct statx {
    __u32 stx_mask;        /* Mask of bits indicating
                              filled fields */
    __u32 stx_blksize;     /* Block size for filesystem I/O */
    __u64 stx_attributes;  /* Extra file attribute indicators */
    __u32 stx_nlink;       /* Number of hard links */
    __u32 stx_uid;         /* User ID of owner */
    __u32 stx_gid;         /* Group ID of owner */
    __u16 stx_mode;        /* File type and mode */
    __u64 stx_ino;         /* Inode number */
    __u64 stx_size;        /* Total size in bytes */
    __u64 stx_blocks;      /* Number of 512B blocks allocated */
    __u64 stx_attributes_mask;
                           /* Mask to show what's supported
                              in stx_attributes */

    /* The following fields are file timestamps */
    struct statx_timestamp stx_atime;  /* Last access */
    struct statx_timestamp stx_btime;  /* Creation */
    struct statx_timestamp stx_ctime;  /* Last status change */
    struct statx_timestamp stx_mtime;  /* Last modification */

    /* If this file represents a device, then the next two
       fields contain the ID of the device */
    __u32 stx_rdev_major;  /* Major ID */
    __u32 stx_rdev_minor;  /* Minor ID */

    /* The next two fields contain the ID of the device
       containing the filesystem where the file resides */
    __u32 stx_dev_major;   /* Major ID */
    __u32 stx_dev_minor;   /* Minor ID */
};