Packaging:Tmpfiles.d

Overview
tmpfiles.d is a service provided by both systemd and upstart in Fedora 15 and later for managing temporary files and directories for daemons. In this guideline we mainly concentrate on how it is used to populate  and. In Fedora 15 and later,  and   are tmpfs filesystems. As such, they are created empty on every reboot. For files intended to be placed into those directories, this should normally not pose any problems. For directories, however, we often need to create the directories ahead of time. This is best done using the tmpfiles.d mechanism that both upstart and systemd share.

tmpfiles.d configuration
Configuring tmpfiles.d just involves dropping a file into  that tells the init system what directories need to be created.

For example, if the package needs a few directories to be created in  in order for it to run, the packager needs to create a file named   that is installed as. That file has the following lines:

D /var/run/NAME 0710 root GROUP -

The format of the line is as follows:


 * specifies that a directory is to be created if it doesn't exist; empties it if it does exist.
 * is the filesystem path to create. Substitute NAME with the name of the directory that's needed
 * are the permissions to apply to the directory when it is created
 * is the owner of the directory. You can change this if needed.
 * is the group that owns the directory. GROUP with the group that should own the directory.
 * the last field is for age (if used should be a time specification such as ) which specifies to delete some files in the directory automatically in regular intervals. This is mostly useful for directories such as /tmp and is seldom used by packages.

Information on other options is available on the tmpfiles.d man page should you need to do something more advanced.

Example spec file
In the spec file, the packager needs to install the tmpfiles.d conf file and also make sure the directory is included in the rpm. Source1: %{name}-tmpfiles.conf Requires: initscripts [...]
 * 1) tmpfiles.d configuration for the /var/run directory

%install mkdir -p %{buildroot}%{_sysconfdir}/tmpfiles.d install -m 0644 %{SOURCE1} %{buildroot}%{_sysconfdir}/tmpfiles.d/%{name}.conf

mkdir -p %{buildroot}%{_localstatedir}/run/ install -d -m 0710 %{buildroot}%{_localstatedir}/run/%{name}/ [...]
 * 1) The next two lines may not be needed if the upstream's install script creates them

%files %dir %{_localstatedir}/run/%{name}/ %config(noreplace) %{_sysconfdir}/tmpfiles.d/%{name}.conf

Files that the program places directly into  or   or into subdirectories of those may be listed in the %files section as   but you may also omit them entirely as the files will be cleaned up on every reboot.

Why not create the directories with XXXXXX instead?
There are multiple ways to try creating the directories but most suffer some disadvantage that tmpfiles.d addresses:

Have the daemon create the directory when it starts up
Many times, daemons run as an unprivileged user who would not be allowed to create new directories directly into  or. If the daemon does not drop privileges, then you can patch it to create the files and directories when the daemon starts and submit the patch upstream.

Have the init script create the directory when it starts up the daemon
Since the init script is run by root, before the daemon drops privileges, why not create the directories there?


 * This code would need to be implemented in every init script packaged. Since both upstart and systemd support tmpfiles.d, we can cut down on the number of places we have to put code like this.
 * Having to add the mkdir to the systemd unit files when tmpfiles.d is already in place introduces the need to run shell code for that init script. Systemd is no longer able to handle starting the daemon by itself which slows things down.  The shell code also introduces imperative constructs into the otherwise declarative structure which is nice to avoid.
 * Properly labelling the created directories is done automatically by the tmpfiles.d mechanism but would have to be manually done by the init script.