Paul Ciarlo paulyc

Enable persistent storage for the systemd journal log

Overview

The assumed default setting in /etc/systemd/journald.conf is Storage=auto which implies that systemd journaling will only persist the journal if the expected storage location is available. Otherwise, the journal data is stored in memory and lost between reboots. On Ubuntu 16.04, /var/log/journal does not exist by default. Create it to keep and query events from previous boots.

Considerations:

Syslog still provides the persistant log records for Ubuntu 16.04, so enabling persistant systemd journal logging does cause a level of duplicaiton.
There are sane defaults:

Receive GOES-16 and GOES-17 Images with a Raspberry Pi and RTL-SDR dongle

Also see the original Pieter Noordhuis's guide

Hardware

You need:

Raspberry Pi Model B (or B+) with a MicroSD Card $35-40
An RTL-SDR dongle:

Arch Linux Full-Disk Encryption Installation Guide

This guide provides instructions for an Arch Linux installation featuring full-disk encryption via LVM on LUKS and an encrypted boot partition (GRUB) for UEFI systems.

Following the main installation are further instructions to harden against Evil Maid attacks via UEFI Secure Boot custom key enrollment and self-signed kernel and bootloader.

Preface

You will find most of this information pulled from the Arch Wiki and other resources linked thereof.

Note: The system was installed on an NVMe SSD, substitute /dev/nvme0nX with /dev/sdX or your device as needed.

	Follow the WORKAROUND:
	1. Add a comand to /etc/rc.local, add the following line above "exit 0":
	setpci -s 00:1c.2 0x50.B=0x41
	2. Add the same comand to /etc/apm/resume.d/21aspm (which does not exist yet):
	setpci -s 00:1c.2 0x50.B=0x41
	3. Add the following to /etc/modprobe.d/sdhci.conf:
	options sdhci debug_quirks2=4
	4. Re-generate initrd:
	sudo update-initramfs -u -k all
	5. Reboot or reload sdhci module:

	#!/bin/sh
	#
	# Read-only Root-FS for Raspian
	#
	# Modified 2016 by Stefan Bonfert to make it compatible with Raspbian
	# Jessie (vanilla).
	#
	# Modified 2015 by Pascal Rosin to work on raspian-ua-netinst with
	# overlayfs integrated in Linux Kernel >= 3.18.
	#

	======= c-create-contract.sol:FooFactory =======
	EVM assembly:
	/* "c-create-contract.sol":44:150 contract FooFactory {... */
	mstore(0x40, 0x60)
	jumpi(tag_1, iszero(callvalue))
	0x0
	dup1
	revert
	tag_1:
	tag_2:

	/* NOTE: The design decision of the req pool is tuned to get the
	* best possible performance. Below point describes
	* the design decisions:
	* >> reqpool is a buffer queue where the producer adds at the start
	* and consumers consume from the end
	* >> it is strictly one consumer and multiple producers queue
	* >> It is unbounded queue and avoids any resource allocation on heap
	* >> It is lockless and use atomic operation to avoid race condition
	* for consumers
	*/

	/* GET /tiles/:z/:x/:y.mvt */
	/* Retreive a vector tile by tileid */
	router.get('/tiles/:z/:x/:y.mvt', async (req, res) => {
	const { z, x, y } = req.params;

	// calculate the bounding polygon for this tile
	const bbox = mercator.bbox(x, y, z, false);

	// Query the database, using ST_AsMVTGeom() to clip the geometries
	// Wrap the whole query with ST_AsMVT(), which will create a protocol buffer

	This bug was also called moonshine in the beginning
	Basically the following bug is present in all bootroms I have looked at:
	1. When usb is started to get an image over dfu, dfu registers an interface to handle all the commands and allocates a buffer for input and output
	2. if you send data to dfu the setup packet is handled by the main code which then calls out to the interface code
	3. the interface code verifies that wLength is shorter than the input output buffer length and if that's the case it updates a pointer passed as an argument with a pointer to the input output buffer
	4. it then returns wLength which is the length it wants to recieve into the buffer
	5. the usb main code then updates a global var with the length and gets ready to recieve the data packages
	6. if a data package is recieved it gets written to the input output buffer via the pointer which was passed as an argument and another global variable is used to keep track of how many bytes were recieved already
	7. if all the data was recieved th