systemd-journald.conf — Journal service configuration file
systemd-journald.conf
All options are configured in the
                [Journal] section:
Compress=Takes a boolean value. If enabled (the default) data objects that shall be stored in the journal and are larger than a certain threshold are compressed with the XZ compression algorithm before they are written to the file system.
RateLimitInterval=, RateLimitBurst=Configures the rate
                                limiting that is applied to all
                                messages generated on the system. If
                                in the time interval defined by
                                RateLimitInterval=
                                more messages than specified in
                                RateLimitBurst= are
                                logged by a service all further
                                messages within the interval are
                                dropped, until the interval is over. A
                                message about the number of dropped
                                messages is generated. This rate
                                limiting is applied per-service, so
                                that two services which log do not
                                interfere with each other's
                                limit. Defaults to 100 messages in
                                10s. The time specification for
                                RateLimitInterval=
                                may be specified in the following
                                units: s,
                                min,
                                h,
                                ms,
                                us. To turn off any
                                kind of rate limiting, set either
                                value to 0.
SystemMaxUse=, SystemKeepFree=, SystemMaxFileSize=, SystemMinFileSize=, RuntimeMaxUse=, RuntimeKeepFree=, RuntimeMaxFileSize=, RuntimeMinFileSize=Enforce size limits on
                                the journal files stored. The options
                                prefixed with
                                System apply to the
                                journal files when stored on a
                                persistant file system, more
                                specifically
                                /var/log/journal. The
                                options prefixed with
                                Runtime apply to
                                the journal files when stored on a
                                volatile in-memory file system, more
                                specifically
                                /run/log/journal. The
                                former is used only when
                                /var is mounted,
                                writable and the directory
                                /var/log/journal
                                exists. Otherwise only the latter
                                applies. Note that this means that
                                during early boot and if the
                                administrator disabled persistant
                                logging only the latter options apply,
                                while the former apply if persistant
                                logging is enabled and the system is
                                fully booted
                                up. SystemMaxUse=
                                and RuntimeMaxUse=
                                control how much disk space the
                                journal may use up at
                                maximum. Defaults to 10% of the size
                                of the respective file
                                system. SystemKeepFree=
                                and
                                RuntimeKeepFree=
                                control how much disk space the
                                journal shall always leave free for
                                other uses if less than the disk space
                                configured in
                                SystemMaxUse= and
                                RuntimeMaxUse= is
                                available. Defaults to 5% of the size
                                of the respective file
                                system. SystemMaxFileSize=
                                and
                                RuntimeMaxFileSize=
                                control how large individual journal
                                files may grow at maximum. This
                                influences the granularity in which
                                disk space is made available through
                                rotation, i.e. deletion of historic
                                data. Defaults to one eigth of the
                                values configured with
                                SystemMaxUse= and
                                RuntimeMaxUse=, so
                                that usually seven rotated journal
                                files are kept as
                                history. SystemMinFileSize=
                                and
                                RuntimeMinFileSize=
                                control how large individual journal
                                files grow at minimum. Defaults to
                                64K. Specify values in bytes or use
                                K, M, G, T, P, E as units for the
                                specified sizes. Note that size limits
                                are enforced synchronously to journal
                                files as they are extended, and need
                                no explicit rotation step triggered by
                                time.
ForwardToSyslog=, ForwardToKMsg=, ForwardToConsole=Control whether log
                                messages received by the journal
                                daemon shall be forwarded to a
                                traditional syslog daemon, to the
                                kernel log buffer (kmsg), or to the
                                system console. These options take
                                boolean arguments. If forwarding to
                                syslog is enabled but no syslog daemon
                                is running the respective option has
                                no effect. By default only forwarding
                                to syslog is enabled. These settings
                                may be overriden at boot time with the
                                kernel command line options
                                systemd_journald.forward_to_syslog=,
                                systemd_journald.forward_to_kmsg=
                                and
                                systemd_journald.forward_to_console=. If
                                forwarding to the kernel log buffer and
                                ImportKernel= is
                                enabled at the same time care is taken
                                to avoid logging loops. It is safe to
                                use these options in combination.
                                
ImportKernel=Controls whether kernel log messages shall be stored in the journal. Takes a boolean argument and defaults to enabled. Note that currently only one userspace service can read kernel messages at a time, which means that kernel log message reading might get corrupted if it is enabled in more than one service, for example in both the journal and a traditional syslog service.