The term "filesystem" is a fancy word used to describe how your computer keeps tracks of all the files you create.
Whether it's an office document, a configuration file, or thousands of digital photos, your computer has to store a lot of data in a way that's useful for both you and it.
Filesystems like Ext4, XFS, JFS, BtrFS, and so on, are the "languages" your computer uses to keep track of data.
Your desktop or terminal can do a lot to help you find your data quickly.
Your file manager might have, for instance, a filter function so you can quickly see just the image files in your home directory, or it might have a search function that can locate a file by its filename, and so on.
These qualities are known as *file attributes* because they are literally exactly that: They're attributes of the data object, defined by code in file headers and within the filesystem itself.
Standard attributes about files that get recorded by most filesystems include a filename, file size, file type, and time stamps for when the created was created and when it was last visited.
I use the open source XFS filesystem on my computers, not for its reliability and high performance, but for the subtle convenience of extended attributes.
## File attributes
When you save a file, data about that file are saved along with it.
Common attributes tell your operating system whether the access time should be updated, when the data in the file should be synchronized back to disk, and other logistical details.
Which attributes gets saved depends on the capabilities and features of the underlying filesystem.
In addition to standard file attributes (insofar as there are standard attributes), the XFS, Ext4, and BtrFS filesystems are all capable of using extending filesystems.
## Extended attributes
XFS, Ext4, and BtrFS allow you to create your own arbitrary file attributes.
Because you're making up your own attributes, there's nothing built into your operating system to utilize those attributes, but I use them as "tags" for files in much the same way as I use EXIF data on photos.
Developers might choose to use extended attributes to develop custom capabilities in applications.
There are two "namespaces" for attributes in XFS: `user` and `root`.
When creating an attribute, you attribute must be added to one of these namespaces.
To add an attribute to the `root` namespace, you must use the `sudo` command or be logged in as root.
## Adding an attribute
You can add an attribute to a file on an XFS filesystem with the `attr` or `setfattr` command.
The `attr` command assumes the `user` namespace, so you only have to set (`-s`) a name for your attribute followed by a value (`-V`):
```bash
$ attr -s flavor -V vanilla example.txt
Attribute "flavor" set to a 7 byte value for example.txt:
vanilla
```
The `setfattr` command requires that you specify the target namespace:
To see extended attributes you've added to a file, you can use the `attr` or `getfattr` command.
The `attr` command defaults to the `user` namespace and uses the `-g` option to *get* extended attributes:
```bash
$ attr -g flavor example.txt
Attribute "flavor" had a 9 byte value for example.txt:
chocolate
```
The `getfattr` command requires the namespace and name of the attribute:
The greatest risk when using extended attributes is forgetting that these attributes are specific to the filesystem they're on.
That means when you copy a file from one drive or partition to another, the attributes are lost *even if the target filesystem supports extended attributes*.
To avoid losing extended attributes, you must use a tool that supports retaining them, such as the `rsync` command.
No matter what tool you use, should you transfer a file to a filesystem that doesn't know what to do with extended attributes, those attributes are dropped.
## Search for attributes
There aren't many mechanisms to interact with extended attributes, so your options for using file attributes you've added are limited.
I use extended attributes as a tagging mechanism, which allows me to associate files that have no obvious relation to one another.
For instance, suppose I need a Creative Commons graphic for a project I'm working on.
Assume I've had the foresight to add the extended attribute `license` to my collection of graphics.
I could search my graphic folder with `find` and `getfattr` together:
Filesystems aren't generally something you're meant to notice.
They're literally systems for defining a file.
It's not the most exciting task a computer performs, and it's not something users are supposed to have to be concerned with.
But some filesystems give you some fun, and safe, special abilities, and extended file attributes are a good example.
Its use may be limited, but extended attributes are a unique way to add context to your data.
