systemd-pstore.service, systemd-pstore - A service to
          archive contents of pstore



          systemd-pstore.service is a system service that archives the
          contents of the Linux persistent storage filesystem, pstore,
          to other storage, thus preserving the existing information
          contained in the pstore, and clearing pstore storage for
          future error events.

          Linux provides a persistent storage file system, pstore,
          that can store error records when the kernel dies (or
          reboots or powers-off). These records in turn can be
          referenced to debug kernel problems (currently the kernel
          stuffs the tail of the dmesg, which also contains a stack
          backtrace, into pstore).

          The pstore file system supports a variety of backends that
          map onto persistent storage, such as the ACPI ERST and UEFI
          variables. The pstore backends typically offer a relatively
          small amount of persistent storage, e.g. 64KiB, which can
          quickly fill up and thus prevent subsequent kernel crashes
          from recording errors. Thus there is a need to monitor and
          extract the pstore contents so that future kernel problems
          can also record information in the pstore.

          The pstore service is independent of the kdump service. In
          cloud environments specifically, host and guest filesystems
          are on remote filesystems (eg. iSCSI or NFS), thus kdump
          relies (implicitly and/or explicitly) upon proper operation
          of networking software *and* hardware *and* infrastructure.
          Thus it may not be possible to capture a kernel coredump to
          a file since writes over the network may not be possible.

          The pstore backend, on the other hand, is completely local
          and provides a path to store error records which will
          survive a reboot and aid in post-mortem debugging.

          The systemd-pstore executable does the actual work. Upon
          starting, the pstore.conf file is read and the
          /sys/fs/pstore directory contents are processed according to
          the options. Pstore files are written to the journal, and
          optionally saved into /var/lib/systemd/pstore.

     Page 1                     systemd 247          (printed 5/25/22)


          The behavior of systemd-pstore is configured through the
          configuration file /etc/systemd/pstore.conf and
          corresponding snippets /etc/systemd/pstore.conf.d/*.conf,
          see pstore.conf(5).

        Disabling pstore processing
          To disable pstore processing by systemd-pstore, set


          in pstore.conf(5).

        Controlling kernel parameters
          The kernel has two parameters,
          /sys/module/kernel/parameters/crash_kexec_post_notifiers and
          /sys/module/printk/parameters/always_kmsg_dump, that control
          writes into pstore. The crash_kexec_post_notifiers parameter
          enables the kernel to write dmesg (including stack trace)
          into pstore upon a panic or crash, and
          printk.always_kmsg_dump parameter enables the kernel to
          write dmesg upon a normal shutdown (shutdown, reboot, halt).
          These kernel parameters are managed via the tmpfiles.d(5)
          mechanism, specifically the file

          Data stored in the journal can be viewed with journalctl(1)
          as usual.


     Page 2                     systemd 247          (printed 5/25/22)