tree-wide: remove Emacs lines from all files This should be handled fine now by .dir-locals.el, so need to carry that stuff in every file.

journald: add a couple of static asserts checking logging constants Whenever we include a log level or facility in a journal string field, make sure the compiler checks for us that that's actually the right thing to do.

journal: silently skip failing large messages if journald is missing We treated -ENOENT errors with silent failure, for small messages. Do the same for large messages.

journal: unbreak sd_journal_sendv Borked since commit 3ee897d6c2401effbc82f5eef35fce405781d6c8 Author: Lennart Poettering <lennart@poettering.net> Date: Wed Sep 23 01:00:04 2015 +0200 tree-wide: port more code to use send_one_fd() and receive_one_fd() because here our fd is not connected and we need to specify the address.

journal: addition and multiplication do not commute

util-lib: split out allocation calls into alloc-util.[ch]

util-lib: split out printf() helpers to stdio-util.h

util-lib: move more file I/O related calls into fileio.[ch]

util-lib: split out IO related calls to io-util.[ch]

util-lib: split out fd-related operations into fd-util.[ch] There are more than enough to deserve their own .c file, hence move them over.

util-lib: split our string related calls from util.[ch] into its own file string-util.[ch] There are more than enough calls doing string manipulations to deserve its own files, hence do something about it. This patch also sorts the #include blocks of all files that needed to be updated, according to the sorting suggestions from CODING_STYLE. Since pretty much every file needs our string manipulation functions this effectively means that most files have sorted #include blocks now. Also touches a few unrelated include files.

tree-wide: port more code to use send_one_fd() and receive_one_fd() Also, make it slightly more powerful, by accepting a flags argument, and make it safe for handling if more than one cmsg attribute happens to be attached.

Add a snprinf wrapper which checks that the buffer was big enough If we scale our buffer to be wide enough for the format string, we should expect that the calculation was correct. char_array_0() invocations are removed, since snprintf nul-terminates the output in any case. A similar wrapper is used for strftime calls, but only in timedatectl.c.

Assorted format fixes Types used for pids and uids in various interfaces are unpredictable. Too bad.

treewide: sanitize loop_write loop_write() didn't follow the usual systemd rules and returned status partially in errno and required extensive checks from callers. Some of the callers dealt with this properly, but many did not, treating partial writes as successful. Simplify things by conforming to usual rules.

memfd: rename memfd.h to memfd-util.h to avoid any confusion with any libc provided headers

memfd: always use our internal utility functions where we have them

journal: when sending huge log messages prefer memfds over temporary files in /dev/shm Previously when a log message grew beyond the maximum AF_UNIX/SOCK_DGRAM datagram limit we'd send an fd to a deleted file in /dev/shm instead. Because the sender could still modify the file after delivery we had to immediately copy the data on the receiving side. With memfds we can optimize this logic, and also remove the dependency on /dev/shm: simply send a sealed memfd around, and if we detect the seal memory map the fd and use it directly.

journal-send.c: use automatic cleanup

util: replace close_nointr_nofail() by a more useful safe_close() safe_close() automatically becomes a NOP when a negative fd is passed, and returns -1 unconditionally. This makes it easy to write lines like this: fd = safe_close(fd); Which will close an fd if it is open, and reset the fd variable correctly. By making use of this new scheme we can drop a > 200 lines of code that was required to test for non-negative fds or to reset the closed fd variable afterwards.

Get rid of write_safe Current glibc implementation is safe. Kernel does this atomically, and write is actually implemented through writev. So if write is async-signal-safe, than writev pretty much must be too.

journal: guarantee async-signal-safety in sd_journald_sendv signal(7) provides a list of functions which may be called from a signal handler. Other functions, which only call those functions and don't access global memory and are reentrant are also safe. sd_j_sendv was mostly OK, but would call mkostemp and writev in a fallback path, which are unsafe. Being able to call sd_j_sendv in a async-signal-safe way is important because it allows it be used in signal handlers. Safety is achieved by replacing mkostemp with open(O_TMPFILE) and an open-coded writev replacement which uses write. Unfortunately, O_TMPFILE is only available on kernels >= 3.11. When O_TMPFILE is unavailable, an open-coded mkostemp is used. https://bugzilla.gnome.org/show_bug.cgi?id=722889

Replace mkostemp+unlink with open(O_TMPFILE) This will only work on Linux >= 3.11, and probably not on all filesystems. Fallback code is provided.

journal: fail silently in sd_j_sendv() if journal is unavailable "syslog(3) and sd_journal_print() may largely be used interchangeably functionality-wise" according to sd_journal_print(3). This socket should be always available except in rare circumstatances, and we don't random applications to fail on logging, so let's do what syslog did. The alternative of forcing all callers to do error handling for this rare case doesn't really have any benefits, since if they can't log there isn't much they can do anyway. https://bugzilla.redhat.com/show_bug.cgi?id=1023041

Use assert_return in more of the public API

macro: clean up usage of gcc attributes Always use our own macros, and name all our own macros the same style.

remove hasprefix(), use startswith()

Add hasprefix macro to check prefixes of fixed length

journal: use initialization instead of zeroing

Add __attribute__((const, pure, format)) in various places I'm assuming that it's fine if a _const_ or _pure_ function calls assert. It is assumed that the assert won't trigger, and even if it does, it can only trigger on the first call with a given set of parameters, and we don't care if the compiler moves the order of calls.

util: add a bit of syntactic sugar for saving/restoring errno

journal: fix warning about pointer arithmetic ../src/journal/journal-send.c: In function 'sd_journal_sendv': ../src/journal/journal-send.c:250:73: warning: pointer of type 'void *' used in arithmetic [-Wpointer-arith]

journal-send: always send SYSLOG_IDENTIFIER, if we have it https://bugzilla.redhat.com/show_bug.cgi?id=872193

journal-send: unify a bit of code

journal-send: simplification

journal: also use new VA_FORMAT_ADVANCE() macro in sd_journal_send()

journalctl: rework JSON output mode This splits the JSON output mode into different modes: json and json-pretty. The former printing one entry per line, the latter showing JSON objects nicely indented and in multiple lines to make it easier to read for humans.

journal: add sd_journal_perror() to API

journal: fix sd_journal_stream_fd()

journal: fix missing variable initialization

relicense to LGPLv2.1 (with exceptions) We finally got the OK from all contributors with non-trivial commits to relicense systemd from GPL2+ to LGPL2.1+. Some udev bits continue to be GPL2+ for now, but we are looking into relicensing them too, to allow free copy/paste of all code within systemd. The bits that used to be MIT continue to be MIT. The big benefit of the relicensing is that closed source code may now link against libsystemd-login.so and friends.

journal: implicitly add code location to all messages logged with the native interface This logic can be turned off by defining SD_JOURNAL_SUPPRESS_LOCATION before including sd-journal.h. This also saves/restores errno in all logging functions, in order to be useful as logging calls without side-effects. This also adds a couple of __unlikely__ around the early checks in the logging calls, in order to minimize the runtime impact.

log: increase socket buffers for logging by default

journal: when sending journal data via file, place it in /dev/shm, to allow early boot operation, even if it sucks

journal: if the data to be sent is larger than the maximum datagram size resort to passing a temporary fd over native protocol

log: make internal log api log directly to the journal

journal: rename syslog tag to identifier since that's what we call it on the server side.

sd-journal: close reading side of sd_journal_stream_fd() file descriptors

journal: move sockets into their own subdir

journald: add configuration file options to forward all logged data to kmsg, console, syslog

journal: add _public_ to all sd-journal calls, and add parameter checks

journal: implement stdout transport

journal: introduce mandatory sd_journal_printf() priority parameter

journal: add native protocol to journald, and client side API to send journal messages