1/*-
2 * Copyright (c) 2002 Marcel Moolenaar
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * 1. Redistributions of source code must retain the above copyright
10 *    notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 *    notice, this list of conditions and the following disclaimer in the
13 *    documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 */
26
27#include <sys/cdefs.h>
28__FBSDID("$FreeBSD$");
29
30#include <sys/param.h>
31#include <sys/systm.h>
32#include <sys/conf.h>
33#include <sys/cons.h>
34#include <sys/kernel.h>
35#include <sys/proc.h>
36#include <sys/kerneldump.h>
37#include <sys/watchdog.h>
38#include <vm/vm.h>
39#include <vm/vm_param.h>
40#include <vm/pmap.h>
41#include <machine/dump.h>
42#include <machine/elf.h>
43#include <machine/md_var.h>
44#include <machine/pcb.h>
45
46CTASSERT(sizeof(struct kerneldumpheader) == 512);
47
48#define	MD_ALIGN(x)	roundup2((off_t)(x), PAGE_SIZE)
49
50/* Handle buffered writes. */
51static size_t fragsz;
52
53struct dump_pa dump_map[DUMPSYS_MD_PA_NPAIRS];
54
55#if !defined(__powerpc__) && !defined(__sparc__)
56void
57dumpsys_gen_pa_init(void)
58{
59	int n, idx;
60
61	bzero(dump_map, sizeof(dump_map));
62	for (n = 0; n < nitems(dump_map); n++) {
63		idx = n * 2;
64		if (dump_avail[idx] == 0 && dump_avail[idx + 1] == 0)
65			break;
66		dump_map[n].pa_start = dump_avail[idx];
67		dump_map[n].pa_size = dump_avail[idx + 1] - dump_avail[idx];
68	}
69}
70#endif
71
72struct dump_pa *
73dumpsys_gen_pa_next(struct dump_pa *mdp)
74{
75
76	if (mdp == NULL)
77		return (&dump_map[0]);
78
79	mdp++;
80	if (mdp->pa_size == 0)
81		mdp = NULL;
82	return (mdp);
83}
84
85void
86dumpsys_gen_wbinv_all(void)
87{
88
89}
90
91void
92dumpsys_gen_unmap_chunk(vm_paddr_t pa __unused, size_t chunk __unused,
93    void *va __unused)
94{
95
96}
97
98#if !defined(__sparc__)
99int
100dumpsys_gen_write_aux_headers(struct dumperinfo *di)
101{
102
103	return (0);
104}
105#endif
106
107int
108dumpsys_buf_seek(struct dumperinfo *di, size_t sz)
109{
110	static uint8_t buf[DEV_BSIZE];
111	size_t nbytes;
112	int error;
113
114	bzero(buf, sizeof(buf));
115
116	while (sz > 0) {
117		nbytes = MIN(sz, sizeof(buf));
118
119		error = dump_append(di, buf, 0, nbytes);
120		if (error)
121			return (error);
122		sz -= nbytes;
123	}
124
125	return (0);
126}
127
128int
129dumpsys_buf_write(struct dumperinfo *di, char *ptr, size_t sz)
130{
131	size_t len;
132	int error;
133
134	while (sz) {
135		len = di->blocksize - fragsz;
136		if (len > sz)
137			len = sz;
138		memcpy((char *)di->blockbuf + fragsz, ptr, len);
139		fragsz += len;
140		ptr += len;
141		sz -= len;
142		if (fragsz == di->blocksize) {
143			error = dump_append(di, di->blockbuf, 0, di->blocksize);
144			if (error)
145				return (error);
146			fragsz = 0;
147		}
148	}
149	return (0);
150}
151
152int
153dumpsys_buf_flush(struct dumperinfo *di)
154{
155	int error;
156
157	if (fragsz == 0)
158		return (0);
159
160	error = dump_append(di, di->blockbuf, 0, di->blocksize);
161	fragsz = 0;
162	return (error);
163}
164
165CTASSERT(PAGE_SHIFT < 20);
166#define PG2MB(pgs) ((pgs + (1 << (20 - PAGE_SHIFT)) - 1) >> (20 - PAGE_SHIFT))
167
168int
169dumpsys_cb_dumpdata(struct dump_pa *mdp, int seqnr, void *arg)
170{
171	struct dumperinfo *di = (struct dumperinfo*)arg;
172	vm_paddr_t pa;
173	void *va;
174	uint64_t pgs;
175	size_t counter, sz, chunk;
176	int c, error;
177	u_int maxdumppgs;
178
179	error = 0;	/* catch case in which chunk size is 0 */
180	counter = 0;	/* Update twiddle every 16MB */
181	va = NULL;
182	pgs = mdp->pa_size / PAGE_SIZE;
183	pa = mdp->pa_start;
184	maxdumppgs = min(di->maxiosize / PAGE_SIZE, MAXDUMPPGS);
185	if (maxdumppgs == 0)	/* seatbelt */
186		maxdumppgs = 1;
187
188	printf("  chunk %d: %juMB (%ju pages)", seqnr, (uintmax_t)PG2MB(pgs),
189	    (uintmax_t)pgs);
190
191	dumpsys_wbinv_all();
192	while (pgs) {
193		chunk = pgs;
194		if (chunk > maxdumppgs)
195			chunk = maxdumppgs;
196		sz = chunk << PAGE_SHIFT;
197		counter += sz;
198		if (counter >> 24) {
199			printf(" %ju", (uintmax_t)PG2MB(pgs));
200			counter &= (1 << 24) - 1;
201		}
202
203		dumpsys_map_chunk(pa, chunk, &va);
204		wdog_kern_pat(WD_LASTVAL);
205
206		error = dump_append(di, va, 0, sz);
207		dumpsys_unmap_chunk(pa, chunk, va);
208		if (error)
209			break;
210		pgs -= chunk;
211		pa += sz;
212
213		/* Check for user abort. */
214		c = cncheckc();
215		if (c == 0x03)
216			return (ECANCELED);
217		if (c != -1)
218			printf(" (CTRL-C to abort) ");
219	}
220	printf(" ... %s\n", (error) ? "fail" : "ok");
221	return (error);
222}
223
224int
225dumpsys_foreach_chunk(dumpsys_callback_t cb, void *arg)
226{
227	struct dump_pa *mdp;
228	int error, seqnr;
229
230	seqnr = 0;
231	mdp = dumpsys_pa_next(NULL);
232	while (mdp != NULL) {
233		error = (*cb)(mdp, seqnr++, arg);
234		if (error)
235			return (-error);
236		mdp = dumpsys_pa_next(mdp);
237	}
238	return (seqnr);
239}
240
241#if !defined(__sparc__)
242static off_t fileofs;
243
244static int
245cb_dumphdr(struct dump_pa *mdp, int seqnr, void *arg)
246{
247	struct dumperinfo *di = (struct dumperinfo*)arg;
248	Elf_Phdr phdr;
249	uint64_t size;
250	int error;
251
252	size = mdp->pa_size;
253	bzero(&phdr, sizeof(phdr));
254	phdr.p_type = PT_LOAD;
255	phdr.p_flags = PF_R;			/* XXX */
256	phdr.p_offset = fileofs;
257#ifdef __powerpc__
258	phdr.p_vaddr = (do_minidump? mdp->pa_start : ~0L);
259	phdr.p_paddr = (do_minidump? ~0L : mdp->pa_start);
260#else
261	phdr.p_vaddr = mdp->pa_start;
262	phdr.p_paddr = mdp->pa_start;
263#endif
264	phdr.p_filesz = size;
265	phdr.p_memsz = size;
266	phdr.p_align = PAGE_SIZE;
267
268	error = dumpsys_buf_write(di, (char*)&phdr, sizeof(phdr));
269	fileofs += phdr.p_filesz;
270	return (error);
271}
272
273static int
274cb_size(struct dump_pa *mdp, int seqnr, void *arg)
275{
276	uint64_t *sz;
277
278	sz = (uint64_t *)arg;
279	*sz += (uint64_t)mdp->pa_size;
280	return (0);
281}
282
283int
284dumpsys_generic(struct dumperinfo *di)
285{
286	static struct kerneldumpheader kdh;
287	Elf_Ehdr ehdr;
288	uint64_t dumpsize;
289	off_t hdrgap;
290	size_t hdrsz;
291	int error;
292
293#ifndef __powerpc__
294	if (do_minidump)
295		return (minidumpsys(di));
296#endif
297
298	bzero(&ehdr, sizeof(ehdr));
299	ehdr.e_ident[EI_MAG0] = ELFMAG0;
300	ehdr.e_ident[EI_MAG1] = ELFMAG1;
301	ehdr.e_ident[EI_MAG2] = ELFMAG2;
302	ehdr.e_ident[EI_MAG3] = ELFMAG3;
303	ehdr.e_ident[EI_CLASS] = ELF_CLASS;
304#if BYTE_ORDER == LITTLE_ENDIAN
305	ehdr.e_ident[EI_DATA] = ELFDATA2LSB;
306#else
307	ehdr.e_ident[EI_DATA] = ELFDATA2MSB;
308#endif
309	ehdr.e_ident[EI_VERSION] = EV_CURRENT;
310	ehdr.e_ident[EI_OSABI] = ELFOSABI_STANDALONE;	/* XXX big picture? */
311	ehdr.e_type = ET_CORE;
312	ehdr.e_machine = EM_VALUE;
313	ehdr.e_phoff = sizeof(ehdr);
314	ehdr.e_flags = 0;
315	ehdr.e_ehsize = sizeof(ehdr);
316	ehdr.e_phentsize = sizeof(Elf_Phdr);
317	ehdr.e_shentsize = sizeof(Elf_Shdr);
318
319	dumpsys_pa_init();
320
321	/* Calculate dump size. */
322	dumpsize = 0L;
323	ehdr.e_phnum = dumpsys_foreach_chunk(cb_size, &dumpsize) +
324	    DUMPSYS_NUM_AUX_HDRS;
325	hdrsz = ehdr.e_phoff + ehdr.e_phnum * ehdr.e_phentsize;
326	fileofs = MD_ALIGN(hdrsz);
327	dumpsize += fileofs;
328	hdrgap = fileofs - roundup2((off_t)hdrsz, di->blocksize);
329
330	dump_init_header(di, &kdh, KERNELDUMPMAGIC, KERNELDUMP_ARCH_VERSION,
331	    dumpsize);
332
333	error = dump_start(di, &kdh);
334	if (error != 0)
335		goto fail;
336
337	printf("Dumping %ju MB (%d chunks)\n", (uintmax_t)dumpsize >> 20,
338	    ehdr.e_phnum - DUMPSYS_NUM_AUX_HDRS);
339
340	/* Dump ELF header */
341	error = dumpsys_buf_write(di, (char*)&ehdr, sizeof(ehdr));
342	if (error)
343		goto fail;
344
345	/* Dump program headers */
346	error = dumpsys_foreach_chunk(cb_dumphdr, di);
347	if (error < 0)
348		goto fail;
349	error = dumpsys_write_aux_headers(di);
350	if (error < 0)
351		goto fail;
352	dumpsys_buf_flush(di);
353
354	/*
355	 * All headers are written using blocked I/O, so we know the
356	 * current offset is (still) block aligned. Skip the alignement
357	 * in the file to have the segment contents aligned at page
358	 * boundary.
359	 */
360	error = dumpsys_buf_seek(di, (size_t)hdrgap);
361	if (error)
362		goto fail;
363
364	/* Dump memory chunks. */
365	error = dumpsys_foreach_chunk(dumpsys_cb_dumpdata, di);
366	if (error < 0)
367		goto fail;
368
369	error = dump_finish(di, &kdh);
370	if (error != 0)
371		goto fail;
372
373	printf("\nDump complete\n");
374	return (0);
375
376 fail:
377	if (error < 0)
378		error = -error;
379
380	if (error == ECANCELED)
381		printf("\nDump aborted\n");
382	else if (error == E2BIG || error == ENOSPC)
383		printf("\nDump failed. Partition too small.\n");
384	else
385		printf("\n** DUMP FAILED (ERROR %d) **\n", error);
386	return (error);
387}
388#endif
389