Meaningful directories

The $\texttt{/}$ directory represents the root of the tree, because starting from it, we can always find a path to reach every leave. Applications must never create or require special files or subdirectories in the root directory. Other locations in the FHS hierarchy provide more than enough flexibility for any package.

Semantic of the directories that are meaningful to understand PackageFS implementation, is presented here :

• $\texttt{/bin}$ contains commands that may be used by both the system administrator and the users, but they are required when no other file systems are mounted (e.g. in single user mode);
• $\texttt{/boot}$ keeps everything required for the boot process. It stores data that is used before the kernel begins executing user-mode programs;
• $\texttt{/dev}$ directory is the location of special or device files;
• $\texttt{/etc}$ is a very important directory because it stores configuration files. A configuration file is a local file used to control the operation of a program. It must be static and cannot be an executable binary;
• $\texttt{/lib}$ contains those shared library images needed to boot the system and run the commands in the root file system (i.e. by binaries in $\texttt{/bin}$ and $\texttt{/sbin}$ );
• $\texttt{/mnt}$ is provided so that the system administrator may temporarily mount a file system as needed. The content of this directory is a local issue and should not affect the manner in which any program is run;
• $\texttt{/sbin}$ : utilities used for system administration (and other root-only commands) are stored in $\texttt{/sbin}$, $\texttt{/usr/sbin}$, and $\texttt{/usr/local/sbin}$. The first contains binaries essential for booting, restoring, recovering, or repairing the system in addition to the binaries in $\texttt{/bin}$. Programs executed after $\texttt{/usr}$ is known to be mounted (when there are no problems) are generally placed into $\texttt{/usr/sbin}$. Locally-installed system administration programs should be placed into $\texttt{/usr/local/sbin}$;
• $\texttt{/usr}$ holds shareable, read-only data. That means that $\texttt{/usr}$ should be shareable between various FHS-compliant hosts and must not be written to. Any information that is host-specific or varies with time is stored elsewhere;
• $\texttt{/usr/bin}$ is the primary directory of executable commands on the system;
• $\texttt{/usr/include}$ is where all of the system's general-use include files for the C programming language should be placed;
• $\texttt{/usr/lib}$ includes object files, libraries, and internal binaries that are not intended to be executed directly by users or shell scripts. Applications may use a single subdirectory under $\texttt{/usr/lib}$. If an application uses a subdirectory, all architecture-dependent data exclusively used by the application must be placed within that subdirectory;
• $\texttt{/usr/sbin}$ (see $\texttt{/sbin}$);
• $\texttt{/usr/local}$ hierarchy is for use by the system administrator when installing software locally. It needs to be safe from being overwritten when the system software is updated. It may be used for programs and data that are shareable amongst a group of hosts, but not found in $\texttt{/usr}$;
• $\texttt{/usr/share}$ stores all read-only architecture independent data files like program release notes, info and documentation. It includes also the subtree $\texttt{/usr/share/man}$ which includes system reference manual pages;
• $\texttt{/var}$ contains variable data files. This includes spool directories and files, administrative and logging data, and transient and temporary files. $\texttt{/var}$ is specified in the FHS in order to make it possible to mount $\texttt{/usr}$ read-only. Since $\texttt{/var}$ does not contain packages static data files (except for their subdirectories), we will notice only free subdirectories in each PackageFS installed package subtree.
• $\texttt{/var/cache}$ is intended for cached data from applications, that must be able to regenerate or restore the data. Unlike $\texttt{/var/spool}$ , the cached files can be deleted without data loss. The data must remain valid between invocations of the application and rebooting the system.
• $\texttt{/var/lib}$ holds state information pertaining to an application or the system. State information is data that programs modify while they run, and that pertains to one specific host. Users must never need to modify files in this directory to configure a package's operation.
• $\texttt{/var/lock}$ and $\texttt{/var/run}$ store some run-time information;
• $\texttt{/var/log}$ contains miscellaneous log files. Most logs must be written to this directory or an appropriate subdirectory;
• $\texttt{/var/spool}$ holds data which is awaiting some kind of later processing;
• $\texttt{/tmp}$ must be made available for programs that require temporary files.

According to the FHS semantic, any user who would take a look at a software configuration file, should search for it in the $\texttt{/etc}$ directory tree. There he finds all of the configuration files of the system, and many of them are not placed under separate subdirectories. So, even a medium-experienced administrator can sense it difficult to get the specific package's file he needs. Otherwise, if he could look into the package rooted subtree, he easily discovers the $\texttt{/etc}$ directory entry that satisfies his research.

As we will see, PackageFS is not just a try to ease package management for the less-experienced system administrator, but it mainly provides an additional view of the file system through which he is able to access and modify all of the files installed on the machine.