Differential D4712 Diff 18921 sys/kern/kern_shutdown.c

Changeset View

Standalone View

sys/kern/kern_shutdown.c

Show All 32 Lines
*		*
* @(#)kern_shutdown.c 8.3 (Berkeley) 1/21/94		* @(#)kern_shutdown.c 8.3 (Berkeley) 1/21/94
*/		*/

#include <sys/cdefs.h>		#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");		__FBSDID("$FreeBSD$");

#include "opt_ddb.h"		#include "opt_ddb.h"
		#include "opt_ekcd.h"
#include "opt_kdb.h"		#include "opt_kdb.h"
#include "opt_panic.h"		#include "opt_panic.h"
#include "opt_sched.h"		#include "opt_sched.h"
#include "opt_watchdog.h"		#include "opt_watchdog.h"

#include <sys/param.h>		#include <sys/param.h>
#include <sys/systm.h>		#include <sys/systm.h>
#include <sys/bio.h>		#include <sys/bio.h>
Show All 17 Lines
#include <sys/rwlock.h>		#include <sys/rwlock.h>
#include <sys/sched.h>		#include <sys/sched.h>
#include <sys/smp.h>		#include <sys/smp.h>
#include <sys/sysctl.h>		#include <sys/sysctl.h>
#include <sys/sysproto.h>		#include <sys/sysproto.h>
#include <sys/vnode.h>		#include <sys/vnode.h>
#include <sys/watchdog.h>		#include <sys/watchdog.h>

		#include <crypto/rijndael/rijndael-api-fst.h>
		#include <crypto/sha2/sha256.h>

#include <ddb/ddb.h>		#include <ddb/ddb.h>

#include <machine/cpu.h>		#include <machine/cpu.h>
#include <machine/dump.h>		#include <machine/dump.h>
#include <machine/pcb.h>		#include <machine/pcb.h>
#include <machine/smp.h>		#include <machine/smp.h>

#include <security/mac/mac_framework.h>		#include <security/mac/mac_framework.h>
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Lines
#endif		#endif
SYSCTL_INT(_kern_shutdown, OID_AUTO, show_busybufs, CTLFLAG_RW,		SYSCTL_INT(_kern_shutdown, OID_AUTO, show_busybufs, CTLFLAG_RW,
&show_busybufs, 0, "");		&show_busybufs, 0, "");

int suspend_blocked = 0;		int suspend_blocked = 0;
SYSCTL_INT(_kern, OID_AUTO, suspend_blocked, CTLFLAG_RW,		SYSCTL_INT(_kern, OID_AUTO, suspend_blocked, CTLFLAG_RW,
&suspend_blocked, 0, "Block suspend due to a pending shutdown");		&suspend_blocked, 0, "Block suspend due to a pending shutdown");

		#ifdef EKCD
		FEATURE(ekcd, "Encrypted kernel crash dumps support");

		MALLOC_DEFINE(M_EKCD, "ekcd", "Encrypted kernel crash dumps data");

		struct kerneldumpcrypto {
		uint8_t kdc_encryption;
		uint8_t kdc_iv[KERNELDUMP_IV_MAX_SIZE];
		keyInstance kdc_ki;
		cipherInstance kdc_ci;
		off_t kdc_nextoffset;
		uint32_t kdc_dumpkeysize;
		uint32_t kdc_encryptedkeysize;
		uint8_t kdc_encryptedkey[];
		};
		#endif

/*		/*
* Variable panicstr contains argument to first call to panic; used as flag		* Variable panicstr contains argument to first call to panic; used as flag
* to indicate that the kernel has already called panic.		* to indicate that the kernel has already called panic.
*/		*/
const char *panicstr;		const char *panicstr;

int dumping; /* system is dumping */		int dumping; /* system is dumping */
int rebooting; /* system is rebooting */		int rebooting; /* system is rebooting */
▲ Show 20 Lines • Show All 679 Lines • ▼ Show 20 Lines	kthread_shutdown(void *arg, int howto)
else		else
printf("done\n");		printf("done\n");
}		}

static char dumpdevname[sizeof(((struct cdev*)NULL)->si_name)];		static char dumpdevname[sizeof(((struct cdev*)NULL)->si_name)];
SYSCTL_STRING(_kern_shutdown, OID_AUTO, dumpdevname, CTLFLAG_RD,		SYSCTL_STRING(_kern_shutdown, OID_AUTO, dumpdevname, CTLFLAG_RD,
dumpdevname, 0, "Device for kernel dumps");		dumpdevname, 0, "Device for kernel dumps");

		#ifdef EKCD
		static struct kerneldumpcrypto *
		kerneldumpcrypto_create(size_t blocksize, uint8_t encryption,
		const uint8_t key, uint32_t encryptedkeysize, const uint8_t encryptedkey)
		{
		struct kerneldumpcrypto *kdc;

		kdc = malloc(sizeof(*kdc) + encryptedkeysize, M_EKCD,
		M_WAITOK \| M_ZERO);

		cemUnsubmitted Done Inline Actions `dumpkeysize = roundup2(sizeof(kdk) + encryptedkeysize, blocksize);` cem:* `dumpkeysize = roundup2(sizeof(*kdk) + encryptedkeysize, blocksize);`
		arc4rand(kdc->kdc_iv, sizeof(kdc->kdc_iv), 0);

		cemUnsubmitted Done Inline Actions Do we care if dumpkey is block aligned (kdc isn't likely to be block sized)? cem: Do we care if dumpkey is block aligned (kdc isn't likely to be block sized)?
		defAuthorUnsubmitted Not Done Inline Actions kdc_dumpkey has struct kerneldumpkey[] type now. def: kdc_dumpkey has struct kerneldumpkey[] type now.
		kdc->kdc_encryption = encryption;
		switch (kdc->kdc_encryption) {
		case KERNELDUMP_ENC_AES_256_CBC:
		if (rijndael_makeKey(&kdc->kdc_ki, DIR_ENCRYPT, 256, key) <= 0)
		goto failed;
		break;
		default:
		goto failed;
		}

		kdc->kdc_encryptedkeysize = encryptedkeysize;
		bcopy(encryptedkey, kdc->kdc_encryptedkey, kdc->kdc_encryptedkeysize);

		kdc->kdc_dumpkeysize = ((sizeof(kdc->kdc_encryption) +
		sizeof(kdc->kdc_iv) + sizeof(kdc->kdc_encryptedkeysize) +
		cemUnsubmitted Done Inline Actions This alias increases the alignment requirements and may produce bus errors outside of x86, I think. Instead, maybe make the type of the kdc_dumpkey array `struct kerneldumpkey[]` so that the struct member is suitably aligned. cem: This alias increases the alignment requirements and may produce bus errors outside of x86, I…
		kdc->kdc_encryptedkeysize + blocksize - 1) / blocksize) * blocksize;

		return (kdc);
		failed:
		explicit_bzero(kdc, sizeof(*kdc) + encryptedkeysize);
		free(kdc, M_EKCD);
		return (NULL);
		}
		#endif /* EKCD */

		int
		kerneldumpcrypto_init(struct kerneldumpcrypto *kdc)
		{
		#ifndef EKCD
		return (0);
		#else
		uint8_t hash[SHA256_DIGEST_LENGTH];
		SHA256_CTX ctx;
		int error;

		error = 0;

		if (kdc == NULL)
		return (0);

		/*
		* When a user enters ddb it can write a crash dump multiple times.
		* Each time it should be encrypted using a different IV.
		*/
		SHA256_Init(&ctx);
		SHA256_Update(&ctx, kdc->kdc_iv, sizeof(kdc->kdc_iv));
		SHA256_Final(hash, &ctx);
		cemUnsubmitted Not Done Inline Actions Why should it use a different IV (maybe for network dumps, which we don't support today)? And if it should use a different IV, why make that subsequent IV predictable (sha256 of the previous one) instead of arc4random()? cem: Why should it use a different IV (maybe for network dumps, which we don't support today)? And…
		pjdUnsubmitted Not Done Inline Actions We don't want the same IV, because user may enter DDB, do a crash dump, change dump device and do it again. We would end up with two crash dumps encrypted with the same IV. Or even if user won't switch dump device, so other user may read its content after first dump and before second dump. I also remember there was a reason to use SHA256 instead of arc4random(). Maybe arc4random() may need scheduler? pjd: We don't want the same IV, because user may enter DDB, do a crash dump, change dump device and…
		bcopy(hash, kdc->kdc_iv, sizeof(kdc->kdc_iv));

		switch (kdc->kdc_encryption) {
		case KERNELDUMP_ENC_AES_256_CBC:
		if (rijndael_cipherInit(&kdc->kdc_ci, MODE_CBC,
		kdc->kdc_iv) <= 0) {
		error = EINVAL;
		goto out;
		}
		break;
		default:
		error = EINVAL;
		goto out;
		}

		kdc->kdc_nextoffset = 0;
		cemUnsubmitted Done Inline Actions Given this is also the successful exit path, maybe rename `failed` label to just `out`. cem: Given this is also the successful exit path, maybe rename `failed` label to just `out`.
		out:
		explicit_bzero(hash, sizeof(hash));
		return (error);
		#endif
		}

		uint32_t
		kerneldumpcrypto_dumpkeysize(const struct kerneldumpcrypto *kdc)
		{

		#ifdef EKCD
		if (kdc == NULL)
		return (0);
		return (kdc->kdc_dumpkeysize);
		#else
		return (0);
		#endif
		}

/* Registration of dumpers */		/* Registration of dumpers */
int		int
set_dumper(struct dumperinfo di, const char devname, struct thread *td)		set_dumper(struct dumperinfo di, const char devname, struct thread *td,
		uint8_t encryption, const uint8_t *key, uint32_t encryptedkeysize,
		const uint8_t *encryptedkey)
{		{
size_t wantcopy;		size_t wantcopy;
int error;		int error;

error = priv_check(td, PRIV_SETDUMPER);		error = priv_check(td, PRIV_SETDUMPER);
if (error != 0)		if (error != 0)
return (error);		return (error);

if (di == NULL) {		if (di == NULL) {
if (dumper.blockbuf != NULL)		error = 0;
free(dumper.blockbuf, M_DUMPER);		goto cleanup;
bzero(&dumper, sizeof(dumper));
dumpdevname[0] = '\0';
return (0);
}		}
if (dumper.dumper != NULL)		if (dumper.dumper != NULL)
return (EBUSY);		return (EBUSY);
dumper = *di;		dumper = *di;
		dumper.blockbuf = NULL;
		dumper.kdc = NULL;

		if (encryption != KERNELDUMP_ENC_NONE) {
		#ifdef EKCD
		dumper.kdc = kerneldumpcrypto_create(di->blocksize, encryption,
		key, encryptedkeysize, encryptedkey);
		if (dumper.kdc == NULL) {
		error = EINVAL;
		goto cleanup;
		}
		#else
		error = EOPNOTSUPP;
		goto cleanup;
		#endif
		}

wantcopy = strlcpy(dumpdevname, devname, sizeof(dumpdevname));		wantcopy = strlcpy(dumpdevname, devname, sizeof(dumpdevname));
if (wantcopy >= sizeof(dumpdevname)) {		if (wantcopy >= sizeof(dumpdevname)) {
printf("set_dumper: device name truncated from '%s' -> '%s'\n",		printf("set_dumper: device name truncated from '%s' -> '%s'\n",
devname, dumpdevname);		devname, dumpdevname);
}		}

dumper.blockbuf = malloc(di->blocksize, M_DUMPER, M_WAITOK \| M_ZERO);		dumper.blockbuf = malloc(di->blocksize, M_DUMPER, M_WAITOK \| M_ZERO);
return (0);		return (0);
		cleanup:
		#ifdef EKCD
		if (dumper.kdc != NULL) {
		explicit_bzero(dumper.kdc, sizeof(*dumper.kdc) +
		dumper.kdc->kdc_encryptedkeysize);
		free(dumper.kdc, M_EKCD);
}		}
		#endif
		if (dumper.blockbuf != NULL) {
		explicit_bzero(dumper.blockbuf, dumper.blocksize);
		free(dumper.blockbuf, M_DUMPER);
		}
		explicit_bzero(&dumper, sizeof(dumper));
		dumpdevname[0] = '\0';
		return (error);
		}

/* Call dumper with bounds checking. */		static int
int		dump_check_bounds(struct dumperinfo *di, off_t offset, size_t length)
dump_write(struct dumperinfo di, void virtual, vm_offset_t physical,
off_t offset, size_t length)
{		{

if (length != 0 && (offset < di->mediaoffset \|\|		if (length != 0 && (offset < di->mediaoffset \|\|
offset - di->mediaoffset + length > di->mediasize)) {		offset - di->mediaoffset + length > di->mediasize)) {
printf("Attempt to write outside dump device boundaries.\n"		printf("Attempt to write outside dump device boundaries.\n"
"offset(%jd), mediaoffset(%jd), length(%ju), mediasize(%jd).\n",		"offset(%jd), mediaoffset(%jd), length(%ju), mediasize(%jd).\n",
(intmax_t)offset, (intmax_t)di->mediaoffset,		(intmax_t)offset, (intmax_t)di->mediaoffset,
(uintmax_t)length, (intmax_t)di->mediasize);		(uintmax_t)length, (intmax_t)di->mediasize);
return (ENOSPC);		return (ENOSPC);
}		}
return (di->dumper(di->priv, virtual, physical, offset, length));
		return (0);
}		}

		#ifdef EKCD
		static int
		dump_encrypt(struct kerneldumpcrypto kdc, uint8_t buf, size_t size)
		{

		switch (kdc->kdc_encryption) {
		case KERNELDUMP_ENC_AES_256_CBC:
		if (rijndael_blockEncrypt(&kdc->kdc_ci, &kdc->kdc_ki, buf,
		8 * size, buf) <= 0) {
		return (EIO);
		}
		if (rijndael_cipherInit(&kdc->kdc_ci, MODE_CBC,
		buf + size - 16 /* IV size for AES-256-CBC */) <= 0) {
		return (EIO);
		}
		break;
		default:
		return (EINVAL);
		}

		return (0);
		}

		cemUnsubmitted Done Inline Actions Maybe make this `static`. cem: Maybe make this `static`.
		/* Encrypt data and call dumper. */
		static int
		dump_encrypted_write(struct dumperinfo di, void virtual, vm_offset_t physical,
		off_t offset, size_t length)
		{
		static uint8_t buf[KERNELDUMP_BUFFER_SIZE];
		struct kerneldumpcrypto *kdc;
		int error;
		size_t nbytes;
		off_t nextoffset;

		kdc = di->kdc;

		error = dump_check_bounds(di, offset, length);
		if (error != 0)
		return (error);

		/* Signal completion. */
		if (virtual == NULL && physical == 0 && offset == 0 && length == 0) {
		return (di->dumper(di->priv, virtual, physical, offset,
		length));
		}

		/* Data have to be aligned to block size. */
		if ((length % di->blocksize) != 0)
		return (EINVAL);

		/*
		* Data have to be written continuously becase we're encrypting using
		* CBC mode which has this assumption.
		*/
		if (kdc->kdc_nextoffset != 0 && kdc->kdc_nextoffset != offset)
		return (EINVAL);

		nextoffset = offset + (off_t)length;
		cemUnsubmitted Done Inline Actions nbytes = MIN(length, sizeof(buf)); cem: nbytes = MIN(length, sizeof(buf));

		while (length > 0) {
		nbytes = MIN(length, sizeof(buf));
		cemUnsubmitted Done Inline Actions Does `rijndael_blockEncrypt` really support src == dst? Why have dump_encrypt take a src and dst parameter at all if we're only going to use it with both equal? cem: Does `rijndael_blockEncrypt` really support src == dst? Why have dump_encrypt take a src and…
		defAuthorUnsubmitted Done Inline Actions Yes, rijndael_blockEncrypt supports it. It's already used in gbde(8) in g_bde_crypt_delete (sys/geom/bde/g_bde_crypt.c) via AES_encrypt. def: Yes, rijndael_blockEncrypt supports it. It's already used in gbde(8) in g_bde_crypt_delete…
		cemUnsubmitted Done Inline Actions Why have dump_encrypt take a src and dst parameter at all if we're only going to use it with both equal? cem: > Why have dump_encrypt take a src and dst parameter at all if we're only going to use it with…
		cemUnsubmitted Done Inline Actions Nevermind, I see dump_encrypt() was changed to only take the one pointer. Sorry about that. cem: Nevermind, I see dump_encrypt() was changed to only take the one pointer. Sorry about that.
		bcopy(virtual, buf, nbytes);

		if (dump_encrypt(kdc, buf, nbytes) != 0)
		return (EIO);

		error = di->dumper(di->priv, buf, physical, offset, nbytes);
		if (error != 0)
		return (error);

		offset += nbytes;
		virtual = (void )((uint8_t )virtual + nbytes);
		length -= nbytes;
		}

		kdc->kdc_nextoffset = nextoffset;

		return (0);
		}
		#endif /* EKCD */

/* Call dumper with bounds checking. */		/* Call dumper with bounds checking. */
		static int
		dump_raw_write(struct dumperinfo di, void virtual, vm_offset_t physical,
		off_t offset, size_t length)
		{
		int error;

		error = dump_check_bounds(di, offset, length);
		if (error != 0)
		return (error);

		return (di->dumper(di->priv, virtual, physical, offset, length));
		}

int		int
dump_write_pad(struct dumperinfo di, void virtual, vm_offset_t physical,		dump_write(struct dumperinfo di, void virtual, vm_offset_t physical,
off_t offset, size_t length, size_t *size)		off_t offset, size_t length)
{		{
char *temp;
int ret;

		#ifdef EKCD
		if (di->kdc != NULL) {
		return (dump_encrypted_write(di, virtual, physical, offset,
		length));
		}
		#endif

		return (dump_raw_write(di, virtual, physical, offset, length));
		}

		static int
		dump_pad(struct dumperinfo di, void virtual, size_t length, void **buf,
		size_t *size)
		{

if (length > di->blocksize)		if (length > di->blocksize)
return (ENOMEM);		return (ENOMEM);

*size = di->blocksize;		*size = di->blocksize;
if (length == di->blocksize)		if (length == di->blocksize) {
temp = virtual;		*buf = virtual;
else {		} else {
temp = di->blockbuf;		*buf = di->blockbuf;
memset(temp + length, 0, di->blocksize - length);		memcpy(*buf, virtual, length);
memcpy(temp, virtual, length);		memset((uint8_t )buf + length, 0, di->blocksize - length);
}		}
ret = dump_write(di, temp, physical, offset, *size);

		return (0);
		}

		static int
		dump_raw_write_pad(struct dumperinfo di, void virtual, vm_offset_t physical,
		off_t offset, size_t length, size_t *size)
		{
		void *buf;
		int error;

		error = dump_pad(di, virtual, length, &buf, size);
		if (error != 0)
		return (error);

		return (dump_raw_write(di, buf, physical, offset, *size));
		cemUnsubmitted Done Inline Actions Ew. Can you just use an ordinary struct for this like `kerneldumpheader` does? cem: Ew. Can you just use an ordinary struct for this like `kerneldumpheader` does?
		defAuthorUnsubmitted Done Inline Actions We'd like to write packed data and an ordinary structure can have gaps between fields. geli does similar thing in geom/eli/g_eli.h to encode metadata so it can be used by various architectures. def: We'd like to write packed data and an ordinary structure can have gaps between fields. geli…
		cemUnsubmitted Done Inline Actions We'd like to write packed data and an ordinary structure can have gaps between fields So use `__packed` from sys/cdefs.h. cem: > We'd like to write packed data and an ordinary structure can have gaps between fields So use…
		defAuthorUnsubmitted Done Inline Actions Wouldn't it create bus errors on some architectures, e.g. SPARC [1]? It would be nice to have a way to save a crash dump generated by another architecture. https://docs.oracle.com/cd/E60778_01/html/E60745/bjaby.html#OSSCGbjacr def: Wouldn't it create bus errors on some architectures, e.g. SPARC [1]? It would be nice to have a…
		cemUnsubmitted Done Inline Actions Nope. The compiler is responsible for generating appropriately sized and aligned memory operations and truncating as needed. (I don't think that particular piece of Solaris documentation is relevant, but maybe I'm missing something.) cem: Nope. The compiler is responsible for generating appropriately sized and aligned memory…
		defAuthorUnsubmitted Done Inline Actions This is a quote from the link I sent: Note - If you use #pragma pack to align struct or union members on boundaries other than their natural boundaries, accessing these fields usually leads to a bus error on SPARC. As far as I understand SPARC has strict alignment and it won't be possible to save a crash dump generated by an amd64 machine on a SPARC machine because of alignment differences but correct me if I'm wrong. def: This is a quote from the link I sent: > Note - If you use #pragma pack to align struct or union…
		cemUnsubmitted Done Inline Actions Does Solaris' `#pragma pack` have any relationship to FreeBSD/Clang(/GCC on Sparc64)'s `__packed` aka `__attribute__((__packed__))`? I don't think it does. As far as I understand it, it's completely invalid for a compiler to produce assembly that will generate bus errors when the struct itself is aligned, even if packed. The standards don't say anything about packed, of course, so I don't have anything authoritative to point to here. Strict alignment just means the compiler generates assembly instructions to read the aligned DWORD(s) and uses binary shifts or ANDs to extract the relevant field from the aligned memory read. There is no reason `packed` should generate bus errors. That would be a compiler bug. cem: Does Solaris' `#pragma pack` have any relationship to FreeBSD/Clang(/GCC on Sparc64)'s…
		defAuthorUnsubmitted Done Inline Actions Thanks for the explanation, Conrad. It's fixed now. def: Thanks for the explanation, Conrad. It's fixed now.
		}

		int
		dump_write_pad(struct dumperinfo di, void virtual, vm_offset_t physical,
		off_t offset, size_t length, size_t *size)
		{
		void *buf;
		int error;

		error = dump_pad(di, virtual, length, &buf, size);
		if (error != 0)
		return (error);

		return (dump_write(di, buf, physical, offset, *size));
		}

		int
		dump_write_header(struct dumperinfo di, struct kerneldumpheader kdh,
		vm_offset_t physical, off_t offset)
		{
		size_t size;
		int ret;

		ret = dump_raw_write_pad(di, kdh, physical, offset, sizeof(*kdh),
		&size);
		if (ret == 0 && size != di->blocksize)
		ret = EINVAL;
return (ret);		return (ret);
}		}

		int
		dump_write_key(struct dumperinfo *di, vm_offset_t physical, off_t offset)
		{
		#ifndef EKCD
		return (0);
		#else /* EKCD */
		uint8_t buf, p;
		struct kerneldumpcrypto *kdc;
		uint32_t encryptedkeysize;
		int ret;

		kdc = di->kdc;
		if (kdc == NULL)
		return (0);

		buf = malloc(kdc->kdc_dumpkeysize, M_EKCD, M_WAITOK \| M_ZERO);
		oshogboUnsubmitted Done Inline Actions I just start wonder, is WAITOK here is a good thing? Our process was interrupted by panic so we cannot swap any memory, and there isn't any other way to get more memory after a panic, right? In that case I think we will deadlock here. Maybe we should change it to the NOWAIT and dump some message like "No enough memory" or so. The doc say as well that: Note that M_NOWAIT is required when running in an interrupt context. I'm not expert but this is interrupt context, right? oshogbo: I just start wonder, is WAITOK here is a good thing? Our process was interrupted by panic so we…
		kibUnsubmitted Done Inline Actions No, this is not an interrupt context, really. If you add something like 'NMI interrupt context' definition, then it would be it, but the definition is non-sensical, because it is really any point in the code. Spinlocks cannot protect such context against interrupted execution, and this is the main and fatal difference with the usual interrupt context definition. That said, malloc/UMA data structures are protected by normal (AKA sleepable) mutexes and thus malloc even with M_NOWAIT flag cannot be used from an interrupt context. It can be used from the context of interrupt thread, but this is much harder requirement. In other words, malloc(9) in any form is highly undesirable in the dumping path. kib: No, this is not an interrupt context, really. If you add something like 'NMI interrupt…
		oshogboUnsubmitted Done Inline Actions So do you think that we should have static buffer for it or malloc this memory earlier? oshogbo: So do you think that we should have static buffer for it or malloc this memory earlier?
		defAuthorUnsubmitted Done Inline Actions Thanks Mariusz and Konstantin for discussing this issue. I changed the code to allocate a buffer during a dump device setup. def: Thanks Mariusz and Konstantin for discussing this issue. I changed the code to allocate a…
		kibUnsubmitted Done Inline Actions It would be better that way, as @def said to change. Note that drivers which handle dumpdev might have different idea of dump time, e.g. they could use busdma, which often allocates memory. Still, less reliance on the working kernel subsystems for dump, more reliable it is. My opinion is that such non-trivial things from ddb/panic context should be performed by mechanism like kexec. kib: It would be better that way, as @def said to change. Note that drivers which handle dumpdev…

		p = buf;
		*p = kdc->kdc_encryption;
		p += sizeof(kdc->kdc_encryption);
		bcopy(kdc->kdc_iv, p, sizeof(kdc->kdc_iv));
		p += sizeof(kdc->kdc_iv);
		encryptedkeysize = htod32(kdc->kdc_encryptedkeysize);
		bcopy(&encryptedkeysize, p, sizeof(encryptedkeysize));
		p += sizeof(encryptedkeysize);
		bcopy(kdc->kdc_encryptedkey, p, kdc->kdc_encryptedkeysize);
		p += kdc->kdc_encryptedkeysize;

		ret = dump_raw_write(di, buf, physical, offset, kdc->kdc_dumpkeysize);
		explicit_bzero(buf, kdc->kdc_dumpkeysize);
		free(buf, M_EKCD);
		return (ret);
		#endif /* !EKCD */
		}

void		void
mkdumpheader(struct kerneldumpheader kdh, char magic, uint32_t archver,		mkdumpheader(struct kerneldumpheader kdh, char magic, uint32_t archver,
uint64_t dumplen, uint32_t blksz)		uint64_t dumplen, uint32_t dumpkeysize, uint32_t blksz)
{		{

bzero(kdh, sizeof(*kdh));		bzero(kdh, sizeof(*kdh));
strlcpy(kdh->magic, magic, sizeof(kdh->magic));		strlcpy(kdh->magic, magic, sizeof(kdh->magic));
strlcpy(kdh->architecture, MACHINE_ARCH, sizeof(kdh->architecture));		strlcpy(kdh->architecture, MACHINE_ARCH, sizeof(kdh->architecture));
kdh->version = htod32(KERNELDUMPVERSION);		kdh->version = htod32(KERNELDUMPVERSION);
kdh->architectureversion = htod32(archver);		kdh->architectureversion = htod32(archver);
kdh->dumplength = htod64(dumplen);		kdh->dumplength = htod64(dumplen);
kdh->dumptime = htod64(time_second);		kdh->dumptime = htod64(time_second);
		kdh->dumpkeysize = htod32(dumpkeysize);
kdh->blocksize = htod32(blksz);		kdh->blocksize = htod32(blksz);
strlcpy(kdh->hostname, prison0.pr_hostname, sizeof(kdh->hostname));		strlcpy(kdh->hostname, prison0.pr_hostname, sizeof(kdh->hostname));
strlcpy(kdh->versionstring, version, sizeof(kdh->versionstring));		strlcpy(kdh->versionstring, version, sizeof(kdh->versionstring));
if (panicstr != NULL)		if (panicstr != NULL)
strlcpy(kdh->panicstring, panicstr, sizeof(kdh->panicstring));		strlcpy(kdh->panicstring, panicstr, sizeof(kdh->panicstring));
kdh->parity = kerneldump_parity(kdh);		kdh->parity = kerneldump_parity(kdh);
}		}

Show All 10 Lines