Files and Directories Quiz

Creates a symbolic link (shortcut) that points from one file or directory to another.

Similar to symlink, but the target path is relative to an open directory.

The path to the target file or directory.

The path to the symbolic link itself.

Reads the target path of a symbolic link.

Similar to readlink, but the path is relative to an open directory.

Special value for the fd argument, treating the pathname as absolute.

0 for success, -1 for failure.

The user ID a process uses when accessing resources.

The actual user ID of the user running the program.

A flag in a file's mode that changes the effective user ID during execution.

Similar to set-user-ID, but for group permissions.

The owner's user ID of a file (stored in stat struct).

The group owner's ID of a file (in stat struct).

File's mode word containing access permissions and special flags.

Rules governing who can read, write, and execute a file.

A file creation mask used to control the default permissions of new files. It specifies which permissions are denied.

The octal value representing the file creation mask. Each bit corresponds to a specific permission to be masked off.

The umask value is subtracted from the default permissions of a new file to determine its final permissions.

002: Prevents others from writing. 022: Prevents group members and others from writing. 027: Prevents group members from writing and others from reading, writing, or executing.

Specifies which permissions are allowed instead of which ones are denied, using operators like 'a', 'u', 'g', 'o', '+', '-', '='.

Usually set once on login by the shell's start-up file and rarely changed.

To ensure specific access permissions are granted for newly created files, especially if default permissions are restrictive.

Changing the process's umask only affects the process itself, not its parent (like the shell).

A direct pointer to a file's i-node, allowing multiple names for the same file data.

A special file that stores the path to another file, making it a shortcut to the linked file.

A data structure containing information about a file, including its type, permissions, size, and data block pointers.

The number of directory entries that point to a file's i-node, indicating how many names it has.

Renaming a file on the same filesystem only requires updating directory entries, not moving the file data itself.

Indicates the number of files and subdirectories within a directory, including itself.

Hard links can't cross filesystems, but symbolic links can link to files on different filesystems.

The ln(1) command is used to create a hard link to an existing file, making a new directory entry pointing to its i-node.

A leaf directory is a directory that doesn't contain any subdirectories. It always has a link count of 2, one for itself (.) and another for its parent (.).

Each subdirectory you create inside a parent directory increases the parent's link count by 1. This is because each subdirectory points to the parent directory.

A field in the i-node that identifies what kind of file or directory it is.

Creates a new directory named 'testdir' within the current working directory.

The '.' entry represents the current directory, while the '..' entry points to the parent directory. They are crucial for navigating the file system.

The link count would be at least 3. This includes the entry for itself (.), its parent directory (..), and the entry for the subdirectory.

The parent directory's link count increases by 1 because the newly created subdirectory points to the parent.

The link function creates a hard link, a new directory entry that points to an existing file. If the new path already exists, an error is returned. Only the last component of the new path is created. The rest of the path must already exist.

The linkat function is similar to link, but it uses file descriptors to specify the existing and new paths. It allows for more flexibility, like specifying paths relative to an open directory. It also lets you control whether a link is created to a symbolic link or its target.

A hard link creates a new directory entry that references the same file inode as the original. If the original file is deleted, the hard link will still point to the data. A symbolic link (symlink) creates a file that contains the path to the original file. If the original file is deleted, the symlink will become broken.

This flag for the linkat function determines the behavior when creating a link to a symlink. If set, the link will point to the target of the symlink. If not, the link will point to the symlink itself.

The creation of the new directory entry and the increment of the link count are an atomic operation meaning it happens all at once or not at all. This prevents inconsistencies if an error occurs. In simpler terms, the link is either fully created or not at all.

Typically, hard links must be created within the same file system. This is because different file systems have their own way of managing files and linking between different file systems is often not supported.

Creating a hard link to a directory can create loops in the file system which can lead to inconsistencies and break file system utilities. These loops can cause the system to think that a directory is both a parent and child of itself. This can result in infinite recursion when trying to read or write data to these directories.

It depends on the specific network filesystem implementation. Some network filesystems may allow creating hard links across different machines. This can be problematic because hard links are a very low-level concept and may not work well with how files are handled on network filesystems.

A file that points to another file or directory. It's like a shortcut.

symlinkat lets you create symbolic links relative to an open directory, while symlink creates them based on absolute paths.

They help reveal the target path hidden behind a symbolic link, acting like a 'look-behind-the-shortcut' function.

Symlinkat is useful for creating links relative to an open directory, providing finer control over link creation location.

The lstat() function provides information about a file, including its type, size, permissions, and ownership. It handles symbolic links differently than the stat() function, returning information for the link itself, not its target.

These macros (e.g., S_ISREG, S_ISDIR) help determine the type of file. They extract the file type and compare it to a predefined value, allowing you to identify whether a file is a regular file, directory, symbolic link, etc.

The stat() function provides information about a file, including its type, size, permissions, and ownership. It follows symbolic links and returns information about the linked file's target.

A hard link creates a direct reference to a file's data. A symbolic link stores the path to another file. If the original file is deleted, a hard link still points to the data. A symbolic link becomes broken.

Files on a Unix system can be classified into different types, including regular files, directories, symbolic links, character special files, block special files, FIFOs, and sockets, each serving a different purpose.

You can determine if a file is a symbolic link by looking at its file type. This can be achieved using the stat() or lstat() functions, which provide information about a file, including its type.

The code in Figure 4.3 prints the type of each file passed as a command-line argument. It uses the lstat() function to identify the file type and then prints the corresponding description (regular, directory, symbolic link, etc.). The output is a list of the file names followed by their respective file types.

The process of reducing the size of a file by removing data from the end, making the data beyond the new length inaccessible.

A function that truncates a file to a specified length, reducing the file's size.

This function is similar to truncate(), but it operates on an open file descriptor instead of a file path.

A data structure that holds crucial information about a file, such as its permissions, size, and location on disk.

A record within a directory that points to an i-node, effectively linking a filename to its file.

A hierarchical structure that organizes files and directories, enabling efficient storage and retrieval.

The number of directory entries that point to a file's i-node, representing the number of names a file has.

The -u option tells 'ls' to display the access time of files, while the -c option displays the changed-status time. These options provide more detailed information about file modification.

Operations like creating, deleting, or modifying file entries in a directory affect the access, modification, and changed-status times of both the file and the parent directory. Reading or writing a file only affects the file's i-node.

These functions allow you to modify the access and modification times of files. They use the 'timespec' structure to provide nanosecond precision.

A directory is essentially a file that holds entries. Each entry lists a filename and its corresponding i-node number, which points to the data for that file.

Hard links point directly to the i-node of the file, allowing the same file data to be accessed through multiple file names. Symbolic links are files containing a path to another file, creating a shortcut. Deleting the original file breaks a symbolic link, but doesn't affect a hard link.

The link(2) call creates a hard link to an existing file. The linkat(2) call is similar but uses file descriptors, offering more flexibility to specify paths relative to an open directory. Both ensure atomicity, meaning the link is created fully or not at all.

The futimens() function is a system call that allows you to set the access and modification times of a file. It uses two timespec structures to provide both access and modification times, giving precise control.

The timespec structure is used to represent a point in time, containing two fields: tv_sec (seconds) and tv_nsec (nanoseconds). It's used to specify the timestamp for the access and modification times.

The futimens() function first uses the stat() function to retrieve the current access and modification times of a file. Then, it updates these times using the new times provided in its parameters.

The O_TRUNC flag in the open() function ensures that if the file already exists when you open it, it will be truncated (emptied) and its size will be set to 0.

The O_RDWR flag in the open() function allows you to open a file for both reading and writing. This grants you full access to modify its data.

The futimens() function sets the access time (the last time the file was accessed) of a file without actually accessing it. This means you can update the time stamp without the file being read or written.

The futimens() function sets the modification time (the last time the file was modified) of a file. If you only want to set the modification time, the utime() function is an alternative option.

Symbolic links point to a file's location while hard links point to the file's i-node. Symbolic links can be broken if the target file is deleted, while hard links preserve access even if the original file is deleted.

Creating hard links to directories can cause loops in the file system, leading to potential errors and inconsistencies. File system utilities might break.

The lchown function changes the ownership of a symbolic link itself, not the file it points to. This allows you to modify the permissions of the symbolic link file.

stat follows symbolic links and returns information about the linked file. lstat returns information about the symbolic link itself.

The chown function follows symbolic links to change the ownership of the linked file. This means, changing the owner of the file pointed by the symbolic link.

Functions like mkdir, mkfifo, mknod, and rmdir return an error when given a symbolic link as a pathname argument. Also, the functions that take a file descriptor argument like fstat and fchmod do not follow symbolic links.