a958d363f93d1e28e294be056668fa3df498811e
[dragonfly.git] / usr.bin / gcore / elfcore.c
1 /*-
2  * Copyright (c) 1998 John D. Polstra
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  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  *
26  * $FreeBSD: src/usr.bin/gcore/elfcore.c,v 1.5.2.3 2001/07/11 23:59:11 obrien Exp $
27  * $DragonFly: src/usr.bin/gcore/elfcore.c,v 1.5 2008/06/05 18:06:33 swildner Exp $
28  */
29
30 #define _KERNEL_STRUCTURES
31
32 #include <sys/param.h>
33 #include <sys/lock.h>
34 #include <sys/procfs.h>
35 #include <machine/elf.h>
36 #include <vm/vm_param.h>
37 #include <vm/vm.h>
38 #include <vm/pmap.h>
39 #include <vm/vm_map.h>
40 #include <err.h>
41 #include <errno.h>
42 #include <fcntl.h>
43 #include <stdio.h>
44 #include <stdlib.h>
45 #include <string.h>
46 #include <unistd.h>
47
48 #include "extern.h"
49
50 /*
51  * Code for generating ELF core dumps.
52  */
53
54 typedef void (*segment_callback)(vm_map_entry_t, void *);
55
56 /* Closure for cb_put_phdr(). */
57 struct phdr_closure {
58         Elf_Phdr *phdr;         /* Program header to fill in */
59         Elf_Off offset;         /* Offset of segment in core file */
60 };
61
62 /* Closure for cb_size_segment(). */
63 struct sseg_closure {
64         int count;              /* Count of writable segments. */
65         size_t size;            /* Total size of all writable segments. */
66 };
67
68 static void cb_put_phdr(vm_map_entry_t, void *);
69 static void cb_size_segment(vm_map_entry_t, void *);
70 static void each_writable_segment(vm_map_entry_t, segment_callback,
71     void *closure);
72 static void elf_corehdr(int fd, pid_t, vm_map_entry_t, int numsegs,
73     void *hdr, size_t hdrsize);
74 static void elf_puthdr(vm_map_entry_t, void *, size_t *,
75     const prstatus_t *, const prfpregset_t *, const prpsinfo_t *, int numsegs);
76 static void elf_putnote(void *dst, size_t *off, const char *name, int type,
77     const void *desc, size_t descsz);
78 static void freemap(vm_map_entry_t);
79 static void readhdrinfo(pid_t, prstatus_t *, prfpregset_t *, prpsinfo_t *);
80 static vm_map_entry_t readmap(pid_t);
81
82 /*
83  * Write an ELF coredump for the given pid to the given fd.
84  */
85 void
86 elf_coredump(int fd, pid_t pid)
87 {
88         vm_map_entry_t map;
89         struct sseg_closure seginfo;
90         void *hdr;
91         size_t hdrsize;
92         char memname[64];
93         int memfd;
94         Elf_Phdr *php;
95         int i;
96
97         /* Get the program's memory map. */
98         map = readmap(pid);
99
100         /* Size the program segments. */
101         seginfo.count = 0;
102         seginfo.size = 0;
103         each_writable_segment(map, cb_size_segment, &seginfo);
104
105         /*
106          * Calculate the size of the core file header area by making
107          * a dry run of generating it.  Nothing is written, but the
108          * size is calculated.
109          */
110         hdrsize = 0;
111         elf_puthdr(map, NULL, &hdrsize, NULL, NULL, NULL, seginfo.count);
112
113         /*
114          * Allocate memory for building the header, fill it up,
115          * and write it out.
116          */
117         hdr = malloc(hdrsize);
118         if ((hdr = malloc(hdrsize)) == NULL)
119                 errx(1, "out of memory");
120         elf_corehdr(fd, pid, map, seginfo.count, hdr, hdrsize);
121
122         /* Write the contents of all of the writable segments. */
123         snprintf(memname, sizeof memname, "/proc/%d/mem", pid);
124         if ((memfd = open(memname, O_RDONLY)) == -1)
125                 err(1, "cannot open %s", memname);
126
127         php = (Elf_Phdr *)((char *)hdr + sizeof(Elf_Ehdr)) + 1;
128         for (i = 0;  i < seginfo.count;  i++) {
129                 int nleft = php->p_filesz;
130
131                 lseek(memfd, (off_t)php->p_vaddr, SEEK_SET);
132                 while (nleft > 0) {
133                         char buf[8*1024];
134                         int nwant;
135                         int ngot;
136
137                         nwant = nleft;
138                         if (nwant > sizeof buf)
139                                 nwant = sizeof buf;
140                         ngot = read(memfd, buf, nwant);
141                         if (ngot == -1)
142                                 err(1, "read from %s", memname);
143                         if (ngot < nwant)
144                                 errx(1, "short read from %s:"
145                                     " wanted %d, got %d\n", memname,
146                                     nwant, ngot);
147                         ngot = write(fd, buf, nwant);
148                         if (ngot == -1)
149                                 err(1, "write of segment %d failed", i);
150                         if (ngot != nwant)
151                                 errx(1, "short write");
152                         nleft -= nwant;
153                 }
154                 php++;
155         }
156         close(memfd);
157         free(hdr);
158         freemap(map);
159 }
160
161 /*
162  * A callback for each_writable_segment() to write out the segment's
163  * program header entry.
164  */
165 static void
166 cb_put_phdr(vm_map_entry_t entry, void *closure)
167 {
168         struct phdr_closure *phc = (struct phdr_closure *)closure;
169         Elf_Phdr *phdr = phc->phdr;
170
171         phc->offset = round_page(phc->offset);
172
173         phdr->p_type = PT_LOAD;
174         phdr->p_offset = phc->offset;
175         phdr->p_vaddr = entry->start;
176         phdr->p_paddr = 0;
177         phdr->p_filesz = phdr->p_memsz = entry->end - entry->start;
178         phdr->p_align = PAGE_SIZE;
179         phdr->p_flags = 0;
180         if (entry->protection & VM_PROT_READ)
181                 phdr->p_flags |= PF_R;
182         if (entry->protection & VM_PROT_WRITE)
183                 phdr->p_flags |= PF_W;
184         if (entry->protection & VM_PROT_EXECUTE)
185                 phdr->p_flags |= PF_X;
186
187         phc->offset += phdr->p_filesz;
188         phc->phdr++;
189 }
190
191 /*
192  * A callback for each_writable_segment() to gather information about
193  * the number of segments and their total size.
194  */
195 static void
196 cb_size_segment(vm_map_entry_t entry, void *closure)
197 {
198         struct sseg_closure *ssc = (struct sseg_closure *)closure;
199
200         ssc->count++;
201         ssc->size += entry->end - entry->start;
202 }
203
204 /*
205  * For each segment in the given memory map, call the given function
206  * with a pointer to the map entry and some arbitrary caller-supplied
207  * data.
208  */
209 static void
210 each_writable_segment(vm_map_entry_t map, segment_callback func, void *closure)
211 {
212         vm_map_entry_t entry;
213
214         for (entry = map;  entry != NULL;  entry = entry->next)
215                 (*func)(entry, closure);
216 }
217
218 /*
219  * Write the core file header to the file, including padding up to
220  * the page boundary.
221  */
222 static void
223 elf_corehdr(int fd, pid_t pid, vm_map_entry_t map, int numsegs, void *hdr,
224     size_t hdrsize)
225 {
226         size_t off;
227         prstatus_t status;
228         prfpregset_t fpregset;
229         prpsinfo_t psinfo;
230
231         /* Gather the information for the header. */
232         readhdrinfo(pid, &status, &fpregset, &psinfo);
233
234         /* Fill in the header. */
235         memset(hdr, 0, hdrsize);
236         off = 0;
237         elf_puthdr(map, hdr, &off, &status, &fpregset, &psinfo, numsegs);
238
239         /* Write it to the core file. */
240         if (write(fd, hdr, hdrsize) == -1)
241                 err(1, "write");
242 }
243
244 /*
245  * Generate the ELF coredump header into the buffer at "dst".  "dst" may
246  * be NULL, in which case the header is sized but not actually generated.
247  */
248 static void
249 elf_puthdr(vm_map_entry_t map, void *dst, size_t *off, const prstatus_t *status,
250     const prfpregset_t *fpregset, const prpsinfo_t *psinfo, int numsegs)
251 {
252         size_t ehoff;
253         size_t phoff;
254         size_t noteoff;
255         size_t notesz;
256
257         ehoff = *off;
258         *off += sizeof(Elf_Ehdr);
259
260         phoff = *off;
261         *off += (numsegs + 1) * sizeof(Elf_Phdr);
262
263         noteoff = *off;
264         elf_putnote(dst, off, "FreeBSD", NT_PRSTATUS, status,
265             sizeof *status);
266         elf_putnote(dst, off, "FreeBSD", NT_FPREGSET, fpregset,
267             sizeof *fpregset);
268         elf_putnote(dst, off, "FreeBSD", NT_PRPSINFO, psinfo,
269             sizeof *psinfo);
270         notesz = *off - noteoff;
271
272         /* Align up to a page boundary for the program segments. */
273         *off = round_page(*off);
274
275         if (dst != NULL) {
276                 Elf_Ehdr *ehdr;
277                 Elf_Phdr *phdr;
278                 struct phdr_closure phc;
279
280                 /*
281                  * Fill in the ELF header.
282                  */
283                 ehdr = (Elf_Ehdr *)((char *)dst + ehoff);
284                 ehdr->e_ident[EI_MAG0] = ELFMAG0;
285                 ehdr->e_ident[EI_MAG1] = ELFMAG1;
286                 ehdr->e_ident[EI_MAG2] = ELFMAG2;
287                 ehdr->e_ident[EI_MAG3] = ELFMAG3;
288                 ehdr->e_ident[EI_CLASS] = ELF_CLASS;
289                 ehdr->e_ident[EI_DATA] = ELF_DATA;
290                 ehdr->e_ident[EI_VERSION] = EV_CURRENT;
291                 ehdr->e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
292                 ehdr->e_ident[EI_ABIVERSION] = 0;
293                 ehdr->e_ident[EI_PAD] = 0;
294                 ehdr->e_type = ET_CORE;
295                 ehdr->e_machine = ELF_ARCH;
296                 ehdr->e_version = EV_CURRENT;
297                 ehdr->e_entry = 0;
298                 ehdr->e_phoff = phoff;
299                 ehdr->e_flags = 0;
300                 ehdr->e_ehsize = sizeof(Elf_Ehdr);
301                 ehdr->e_phentsize = sizeof(Elf_Phdr);
302                 ehdr->e_phnum = numsegs + 1;
303                 ehdr->e_shentsize = sizeof(Elf_Shdr);
304                 ehdr->e_shnum = 0;
305                 ehdr->e_shstrndx = SHN_UNDEF;
306
307                 /*
308                  * Fill in the program header entries.
309                  */
310                 phdr = (Elf_Phdr *)((char *)dst + phoff);
311
312                 /* The note segement. */
313                 phdr->p_type = PT_NOTE;
314                 phdr->p_offset = noteoff;
315                 phdr->p_vaddr = 0;
316                 phdr->p_paddr = 0;
317                 phdr->p_filesz = notesz;
318                 phdr->p_memsz = 0;
319                 phdr->p_flags = 0;
320                 phdr->p_align = 0;
321                 phdr++;
322
323                 /* All the writable segments from the program. */
324                 phc.phdr = phdr;
325                 phc.offset = *off;
326                 each_writable_segment(map, cb_put_phdr, &phc);
327         }
328 }
329
330 /*
331  * Emit one note section to "dst", or just size it if "dst" is NULL.
332  */
333 static void
334 elf_putnote(void *dst, size_t *off, const char *name, int type,
335     const void *desc, size_t descsz)
336 {
337         Elf_Note note;
338
339         note.n_namesz = strlen(name) + 1;
340         note.n_descsz = descsz;
341         note.n_type = type;
342         if (dst != NULL)
343                 bcopy(&note, (char *)dst + *off, sizeof note);
344         *off += sizeof note;
345         if (dst != NULL)
346                 bcopy(name, (char *)dst + *off, note.n_namesz);
347         *off += roundup2(note.n_namesz, sizeof(Elf_Size));
348         if (dst != NULL)
349                 bcopy(desc, (char *)dst + *off, note.n_descsz);
350         *off += roundup2(note.n_descsz, sizeof(Elf_Size));
351 }
352
353 /*
354  * Free the memory map.
355  */
356 static void
357 freemap(vm_map_entry_t map)
358 {
359         while (map != NULL) {
360                 vm_map_entry_t next = map->next;
361                 free(map);
362                 map = next;
363         }
364 }
365
366 /*
367  * Read the process information necessary to fill in the core file's header.
368  */
369 static void
370 readhdrinfo(pid_t pid, prstatus_t *status, prfpregset_t *fpregset,
371     prpsinfo_t *psinfo)
372 {
373         char name[64];
374         char line[256];
375         int fd;
376         int i;
377         int n;
378
379         memset(status, 0, sizeof *status);
380         status->pr_version = PRSTATUS_VERSION;
381         status->pr_statussz = sizeof(prstatus_t);
382         status->pr_gregsetsz = sizeof(gregset_t);
383         status->pr_fpregsetsz = sizeof(fpregset_t);
384         status->pr_osreldate = __DragonFly_version;
385         status->pr_pid = pid;
386
387         memset(fpregset, 0, sizeof *fpregset);
388
389         memset(psinfo, 0, sizeof *psinfo);
390         psinfo->pr_version = PRPSINFO_VERSION;
391         psinfo->pr_psinfosz = sizeof(prpsinfo_t);
392
393         /* Read the general registers. */
394         snprintf(name, sizeof name, "/proc/%d/regs", pid);
395         if ((fd = open(name, O_RDONLY)) == -1)
396                 err(1, "cannot open %s", name);
397         if ((n = read(fd, &status->pr_reg, sizeof status->pr_reg)) == -1)
398                 err(1, "read error from %s", name);
399         if (n < sizeof status->pr_reg)
400                 errx(1, "short read from %s: wanted %u, got %d", name,
401                     sizeof status->pr_reg, n);
402         close(fd);
403
404         /* Read the floating point registers. */
405         snprintf(name, sizeof name, "/proc/%d/fpregs", pid);
406         if ((fd = open(name, O_RDONLY)) == -1)
407                 err(1, "cannot open %s", name);
408         if ((n = read(fd, fpregset, sizeof *fpregset)) == -1)
409                 err(1, "read error from %s", name);
410         if (n < sizeof *fpregset)
411                 errx(1, "short read from %s: wanted %u, got %d", name,
412                     sizeof *fpregset, n);
413         close(fd);
414
415         /* Read and parse the process status. */
416         snprintf(name, sizeof name, "/proc/%d/status", pid);
417         if ((fd = open(name, O_RDONLY)) == -1)
418                 err(1, "cannot open %s", name);
419         if ((n = read(fd, line, sizeof line - 1)) == -1)
420                 err(1, "read error from %s", name);
421         if (n > MAXCOMLEN)
422                 n = MAXCOMLEN;
423         for (i = 0;  i < n && line[i] != ' ';  i++)
424                 psinfo->pr_fname[i] = line[i];
425         strncpy(psinfo->pr_psargs, psinfo->pr_fname, PRARGSZ);
426         close(fd);
427 }
428
429 /*
430  * Read the process's memory map using procfs, and return a list of
431  * VM map entries.  Only the non-device read/writable segments are
432  * returned.  The map entries in the list aren't fully filled in; only
433  * the items we need are present.
434  */
435 static vm_map_entry_t
436 readmap(pid_t pid)
437 {
438         char mapname[64];
439         int mapfd;
440         ssize_t mapsize;
441         size_t bufsize;
442         char *mapbuf;
443         int pos;
444         vm_map_entry_t map;
445         vm_map_entry_t *linkp;
446
447         snprintf(mapname, sizeof mapname, "/proc/%d/map", pid);
448         if ((mapfd = open(mapname, O_RDONLY)) == -1)
449                 err(1, "cannot open %s", mapname);
450
451         /*
452          * Procfs requires (for consistency) that the entire memory map
453          * be read with a single read() call.  Start with a reasonbly sized
454          * buffer, and double it until it is big enough.
455          */
456         bufsize = 8 * 1024;
457         mapbuf = NULL;
458         for ( ; ; ) {
459                 if ((mapbuf = realloc(mapbuf, bufsize + 1)) == NULL)
460                         errx(1, "out of memory");
461                 mapsize = read(mapfd, mapbuf, bufsize);
462                 if (mapsize != -1 || errno != EFBIG)
463                         break;
464                 bufsize *= 2;
465                 /* This lseek shouldn't be necessary, but it is. */
466                 lseek(mapfd, (off_t)0, SEEK_SET);
467         }
468         if (mapsize == -1)
469                 err(1, "read error from %s", mapname);
470         if (mapsize == 0)
471                 errx(1, "empty map file %s", mapname);
472         mapbuf[mapsize] = 0;
473         close(mapfd);
474
475         pos = 0;
476         map = NULL;
477         linkp = &map;
478         while (pos < mapsize) {
479                 vm_map_entry_t ent;
480                 vm_offset_t start;
481                 vm_offset_t end;
482                 char prot[4];
483                 char type[16];
484                 int n;
485                 int len;
486
487                 len = 0;
488                 n = sscanf(mapbuf + pos, "%x %x %*d %*d %*x %3[-rwx]"
489                     " %*d %*d %*x %*s %*s %16s%*[\n]%n",
490                     &start, &end, prot, type, &len);
491                 if (n != 4)
492                         errx(1, "ill-formed line in %s", mapname);
493                 pos += len;
494
495                 /* Ignore segments of the wrong kind, and unwritable ones */
496                 if (strncmp(prot, "rw", 2) != 0 ||
497                     (strcmp(type, "default") != 0 &&
498                     strcmp(type, "vnode") != 0 &&
499                     strcmp(type, "swap") != 0))
500                         continue;
501
502                 if ((ent = (vm_map_entry_t)calloc(1, sizeof *ent)) == NULL)
503                         errx(1, "out of memory");
504                 ent->start = start;
505                 ent->end = end;
506                 ent->protection = VM_PROT_READ | VM_PROT_WRITE;
507                 if (prot[2] == 'x')
508                     ent->protection |= VM_PROT_EXECUTE;
509
510                 *linkp = ent;
511                 linkp = &ent->next;
512         }
513         free(mapbuf);
514         return map;
515 }