1 /* Native-dependent code for FreeBSD. 2 3 Copyright (C) 2002-2015 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 #include "defs.h" 21 #include "gdbcore.h" 22 #include "inferior.h" 23 #include "regcache.h" 24 #include "regset.h" 25 #include "gdbthread.h" 26 #include <sys/types.h> 27 #include <sys/procfs.h> 28 #include <sys/sysctl.h> 29 30 #include "elf-bfd.h" 31 #include "fbsd-nat.h" 32 33 /* Return the name of a file that can be opened to get the symbols for 34 the child process identified by PID. */ 35 36 char * 37 fbsd_pid_to_exec_file (struct target_ops *self, int pid) 38 { 39 ssize_t len = PATH_MAX; 40 static char buf[PATH_MAX]; 41 char name[PATH_MAX]; 42 43 #ifdef KERN_PROC_PATHNAME 44 int mib[4]; 45 46 mib[0] = CTL_KERN; 47 mib[1] = KERN_PROC; 48 mib[2] = KERN_PROC_PATHNAME; 49 mib[3] = pid; 50 if (sysctl (mib, 4, buf, &len, NULL, 0) == 0) 51 return buf; 52 #endif 53 54 xsnprintf (name, PATH_MAX, "/proc/%d/exe", pid); 55 len = readlink (name, buf, PATH_MAX - 1); 56 if (len != -1) 57 { 58 buf[len] = '\0'; 59 return buf; 60 } 61 62 return NULL; 63 } 64 65 static int 66 fbsd_read_mapping (FILE *mapfile, unsigned long *start, unsigned long *end, 67 char *protection) 68 { 69 /* FreeBSD 5.1-RELEASE uses a 256-byte buffer. */ 70 char buf[256]; 71 int resident, privateresident; 72 unsigned long obj; 73 int ret = EOF; 74 75 /* As of FreeBSD 5.0-RELEASE, the layout is described in 76 /usr/src/sys/fs/procfs/procfs_map.c. Somewhere in 5.1-CURRENT a 77 new column was added to the procfs map. Therefore we can't use 78 fscanf since we need to support older releases too. */ 79 if (fgets (buf, sizeof buf, mapfile) != NULL) 80 ret = sscanf (buf, "%lx %lx %d %d %lx %s", start, end, 81 &resident, &privateresident, &obj, protection); 82 83 return (ret != 0 && ret != EOF); 84 } 85 86 /* Iterate over all the memory regions in the current inferior, 87 calling FUNC for each memory region. OBFD is passed as the last 88 argument to FUNC. */ 89 90 int 91 fbsd_find_memory_regions (struct target_ops *self, 92 find_memory_region_ftype func, void *obfd) 93 { 94 pid_t pid = ptid_get_pid (inferior_ptid); 95 char *mapfilename; 96 FILE *mapfile; 97 unsigned long start, end, size; 98 char protection[4]; 99 int read, write, exec; 100 struct cleanup *cleanup; 101 102 mapfilename = xstrprintf ("/proc/%ld/map", (long) pid); 103 cleanup = make_cleanup (xfree, mapfilename); 104 mapfile = fopen (mapfilename, "r"); 105 if (mapfile == NULL) 106 error (_("Couldn't open %s."), mapfilename); 107 make_cleanup_fclose (mapfile); 108 109 if (info_verbose) 110 fprintf_filtered (gdb_stdout, 111 "Reading memory regions from %s\n", mapfilename); 112 113 /* Now iterate until end-of-file. */ 114 while (fbsd_read_mapping (mapfile, &start, &end, &protection[0])) 115 { 116 size = end - start; 117 118 read = (strchr (protection, 'r') != 0); 119 write = (strchr (protection, 'w') != 0); 120 exec = (strchr (protection, 'x') != 0); 121 122 if (info_verbose) 123 { 124 fprintf_filtered (gdb_stdout, 125 "Save segment, %ld bytes at %s (%c%c%c)\n", 126 size, paddress (target_gdbarch (), start), 127 read ? 'r' : '-', 128 write ? 'w' : '-', 129 exec ? 'x' : '-'); 130 } 131 132 /* Invoke the callback function to create the corefile segment. 133 Pass MODIFIED as true, we do not know the real modification state. */ 134 func (start, size, read, write, exec, 1, obfd); 135 } 136 137 do_cleanups (cleanup); 138 return 0; 139 } 140