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: releng/10.1/sys/powerpc/powerpc/dump_machdep.c 221173 2011-04-28 16:02:05Z attilio $");
29
30 #include "opt_watchdog.h"
31
32 #include <sys/param.h>
33 #include <sys/systm.h>
34 #include <sys/conf.h>
35 #include <sys/cons.h>
36 #include <sys/kernel.h>
37 #include <sys/kerneldump.h>
38 #include <sys/sysctl.h>
39 #ifdef SW_WATCHDOG
40 #include <sys/watchdog.h>
41 #endif
42 #include <vm/vm.h>
43 #include <vm/pmap.h>
44 #include <machine/elf.h>
45 #include <machine/md_var.h>
46
47 CTASSERT(sizeof(struct kerneldumpheader) == 512);
48
49 /*
50 * Don't touch the first SIZEOF_METADATA bytes on the dump device. This
51 * is to protect us from metadata and to protect metadata from us.
52 */
53 #define SIZEOF_METADATA (64*1024)
54
55 #define MD_ALIGN(x) (((off_t)(x) + PAGE_MASK) & ~PAGE_MASK)
56 #define DEV_ALIGN(x) (((off_t)(x) + (DEV_BSIZE-1)) & ~(DEV_BSIZE-1))
57
58 typedef int callback_t(struct pmap_md *, int, void *);
59
60 static struct kerneldumpheader kdh;
61 static off_t dumplo, fileofs;
62
63 /* Handle buffered writes. */
64 static char buffer[DEV_BSIZE];
65 static size_t fragsz;
66
67 int dumpsys_minidump = 1;
68 SYSCTL_INT(_debug, OID_AUTO, minidump, CTLFLAG_RD, &dumpsys_minidump, 0,
69 "Kernel makes compressed crash dumps");
70
71 static int
72 buf_write(struct dumperinfo *di, char *ptr, size_t sz)
73 {
74 size_t len;
75 int error;
76
77 while (sz) {
78 len = DEV_BSIZE - fragsz;
79 if (len > sz)
80 len = sz;
81 bcopy(ptr, buffer + fragsz, len);
82 fragsz += len;
83 ptr += len;
84 sz -= len;
85 if (fragsz == DEV_BSIZE) {
86 error = di->dumper(di->priv, buffer, 0, dumplo,
87 DEV_BSIZE);
88 if (error)
89 return error;
90 dumplo += DEV_BSIZE;
91 fragsz = 0;
92 }
93 }
94
95 return (0);
96 }
97
98 static int
99 buf_flush(struct dumperinfo *di)
100 {
101 int error;
102
103 if (fragsz == 0)
104 return (0);
105
106 error = di->dumper(di->priv, buffer, 0, dumplo, DEV_BSIZE);
107 dumplo += DEV_BSIZE;
108 fragsz = 0;
109 return (error);
110 }
111
112 static int
113 cb_dumpdata(struct pmap_md *md, int seqnr, void *arg)
114 {
115 struct dumperinfo *di = (struct dumperinfo*)arg;
116 vm_offset_t va;
117 size_t counter, ofs, resid, sz;
118 int c, error, twiddle;
119
120 error = 0;
121 counter = 0; /* Update twiddle every 16MB */
122 twiddle = 0;
123
124 ofs = 0; /* Logical offset within the chunk */
125 resid = md->md_size;
126
127 printf(" chunk %d: %lu bytes ", seqnr, (u_long)resid);
128
129 while (resid) {
130 sz = (resid > DFLTPHYS) ? DFLTPHYS : resid;
131 va = pmap_dumpsys_map(md, ofs, &sz);
132 counter += sz;
133 if (counter >> 24) {
134 printf("%c\b", "|/-\\"[twiddle++ & 3]);
135 counter &= (1<<24) - 1;
136 }
137 #ifdef SW_WATCHDOG
138 wdog_kern_pat(WD_LASTVAL);
139 #endif
140 error = di->dumper(di->priv, (void*)va, 0, dumplo, sz);
141 pmap_dumpsys_unmap(md, ofs, va);
142 if (error)
143 break;
144 dumplo += sz;
145 resid -= sz;
146 ofs += sz;
147
148 /* Check for user abort. */
149 c = cncheckc();
150 if (c == 0x03)
151 return (ECANCELED);
152 if (c != -1)
153 printf("(CTRL-C to abort) ");
154 }
155 printf("... %s\n", (error) ? "fail" : "ok");
156 return (error);
157 }
158
159 static int
160 cb_dumphdr(struct pmap_md *md, int seqnr, void *arg)
161 {
162 struct dumperinfo *di = (struct dumperinfo*)arg;
163 Elf32_Phdr phdr;
164 int error;
165
166 bzero(&phdr, sizeof(phdr));
167 phdr.p_type = PT_LOAD;
168 phdr.p_flags = PF_R; /* XXX */
169 phdr.p_offset = fileofs;
170 phdr.p_vaddr = md->md_vaddr;
171 phdr.p_paddr = md->md_paddr;
172 phdr.p_filesz = md->md_size;
173 phdr.p_memsz = md->md_size;
174 phdr.p_align = PAGE_SIZE;
175
176 error = buf_write(di, (char*)&phdr, sizeof(phdr));
177 fileofs += phdr.p_filesz;
178 return (error);
179 }
180
181 static int
182 cb_size(struct pmap_md *md, int seqnr, void *arg)
183 {
184 uint32_t *sz = (uint32_t*)arg;
185
186 *sz += md->md_size;
187 return (0);
188 }
189
190 static int
191 foreach_chunk(callback_t cb, void *arg)
192 {
193 struct pmap_md *md;
194 int error, seqnr;
195
196 seqnr = 0;
197 md = pmap_scan_md(NULL);
198 while (md != NULL) {
199 error = (*cb)(md, seqnr++, arg);
200 if (error)
201 return (-error);
202 md = pmap_scan_md(md);
203 }
204 return (seqnr);
205 }
206
207 void
208 dumpsys(struct dumperinfo *di)
209 {
210 Elf32_Ehdr ehdr;
211 uint32_t dumpsize;
212 off_t hdrgap;
213 size_t hdrsz;
214 int error;
215
216 bzero(&ehdr, sizeof(ehdr));
217 ehdr.e_ident[EI_MAG0] = ELFMAG0;
218 ehdr.e_ident[EI_MAG1] = ELFMAG1;
219 ehdr.e_ident[EI_MAG2] = ELFMAG2;
220 ehdr.e_ident[EI_MAG3] = ELFMAG3;
221 ehdr.e_ident[EI_CLASS] = ELFCLASS32;
222 #if BYTE_ORDER == LITTLE_ENDIAN
223 ehdr.e_ident[EI_DATA] = ELFDATA2LSB;
224 #else
225 ehdr.e_ident[EI_DATA] = ELFDATA2MSB;
226 #endif
227 ehdr.e_ident[EI_VERSION] = EV_CURRENT;
228 ehdr.e_ident[EI_OSABI] = ELFOSABI_STANDALONE; /* XXX big picture? */
229 ehdr.e_type = ET_CORE;
230 ehdr.e_machine = EM_PPC;
231 ehdr.e_phoff = sizeof(ehdr);
232 ehdr.e_ehsize = sizeof(ehdr);
233 ehdr.e_phentsize = sizeof(Elf32_Phdr);
234 ehdr.e_shentsize = sizeof(Elf32_Shdr);
235
236 /* Calculate dump size. */
237 dumpsize = 0L;
238 ehdr.e_phnum = foreach_chunk(cb_size, &dumpsize);
239 hdrsz = ehdr.e_phoff + ehdr.e_phnum * ehdr.e_phentsize;
240 fileofs = MD_ALIGN(hdrsz);
241 dumpsize += fileofs;
242 hdrgap = fileofs - DEV_ALIGN(hdrsz);
243
244 /* For block devices, determine the dump offset on the device. */
245 if (di->mediasize > 0) {
246 if (di->mediasize <
247 SIZEOF_METADATA + dumpsize + sizeof(kdh) * 2) {
248 error = ENOSPC;
249 goto fail;
250 }
251 dumplo = di->mediaoffset + di->mediasize - dumpsize;
252 dumplo -= sizeof(kdh) * 2;
253 } else
254 dumplo = 0;
255
256 mkdumpheader(&kdh, KERNELDUMPMAGIC, KERNELDUMP_POWERPC_VERSION, dumpsize,
257 di->blocksize);
258
259 printf("Dumping %u MB (%d chunks)\n", dumpsize >> 20,
260 ehdr.e_phnum);
261
262 /* Dump leader */
263 error = di->dumper(di->priv, &kdh, 0, dumplo, sizeof(kdh));
264 if (error)
265 goto fail;
266 dumplo += sizeof(kdh);
267
268 /* Dump ELF header */
269 error = buf_write(di, (char*)&ehdr, sizeof(ehdr));
270 if (error)
271 goto fail;
272
273 /* Dump program headers */
274 error = foreach_chunk(cb_dumphdr, di);
275 if (error < 0)
276 goto fail;
277 buf_flush(di);
278
279 /*
280 * All headers are written using blocked I/O, so we know the
281 * current offset is (still) block aligned. Skip the alignement
282 * in the file to have the segment contents aligned at page
283 * boundary. We cannot use MD_ALIGN on dumplo, because we don't
284 * care and may very well be unaligned within the dump device.
285 */
286 dumplo += hdrgap;
287
288 /* Dump memory chunks (updates dumplo) */
289 error = foreach_chunk(cb_dumpdata, di);
290 if (error < 0)
291 goto fail;
292
293 /* Dump trailer */
294 error = di->dumper(di->priv, &kdh, 0, dumplo, sizeof(kdh));
295 if (error)
296 goto fail;
297
298 /* Signal completion, signoff and exit stage left. */
299 di->dumper(di->priv, NULL, 0, 0, 0);
300 printf("\nDump complete\n");
301 return;
302
303 fail:
304 if (error < 0)
305 error = -error;
306
307 if (error == ECANCELED)
308 printf("\nDump aborted\n");
309 else
310 printf("\n** DUMP FAILED (ERROR %d) **\n", error);
311 }
Cache object: 47549f8158d0f6e09b213b14099d2911
|