| | 1 | /* Machine independent support for SVR4 /proc (process file system) for GDB. |
| | 2 | Copyright 1999 Free Software Foundation, Inc. |
| | 3 | Written by Michael Snyder at Cygnus Solutions. |
| | 4 | Based on work by Fred Fish, Stu Grossman, Geoff Noer, and others. |
| | 5 | |
| | 6 | This file is part of GDB. |
| | 7 | |
| | 8 | This program is free software; you can redistribute it and/or modify |
| | 9 | it under the terms of the GNU General Public License as published by |
| | 10 | the Free Software Foundation; either version 2 of the License, or |
| | 11 | (at your option) any later version. |
| | 12 | |
| | 13 | This program is distributed in the hope that it will be useful, |
| | 14 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
| | 15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| | 16 | GNU General Public License for more details. |
| | 17 | |
| | 18 | You should have received a copy of the GNU General Public License |
| | 19 | along with this program; if not, write to the Free Software Foundation, |
| | 20 | Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ |
| | 21 | |
| | 22 | /* |
| | 23 | * Pretty-print trace of api calls to the /proc api |
| | 24 | * (ioctl or read/write calls). |
| | 25 | * |
| | 26 | */ |
| | 27 | |
| | 28 | #include "defs.h" |
| | 29 | #include "gdbcmd.h" |
| | 30 | |
| | 31 | #if defined (NEW_PROC_API) |
| | 32 | #define _STRUCTURED_PROC 1 |
| | 33 | #endif |
| | 34 | |
| | 35 | #include <stdio.h> |
| | 36 | #include <sys/types.h> |
| | 37 | #include <sys/procfs.h> |
| | 38 | #include <sys/proc.h> /* for struct proc */ |
| | 39 | #ifdef HAVE_SYS_USER_H |
| | 40 | #include <sys/user.h> /* for struct user */ |
| | 41 | #endif |
| | 42 | #include <fcntl.h> /* for O_RDWR etc. */ |
| | 43 | #include <sys/wait.h> |
| | 44 | |
| | 45 | #include "proc-utils.h" |
| | 46 | |
| | 47 | /* Much of the information used in the /proc interface, particularly for |
| | 48 | printing status information, is kept as tables of structures of the |
| | 49 | following form. These tables can be used to map numeric values to |
| | 50 | their symbolic names and to a string that describes their specific use. */ |
| | 51 | |
| | 52 | struct trans { |
| | 53 | long value; /* The numeric value */ |
| | 54 | char *name; /* The equivalent symbolic value */ |
| | 55 | char *desc; /* Short description of value */ |
| | 56 | }; |
| | 57 | |
| | 58 | static int procfs_trace = 0; |
| | 59 | static FILE *procfs_file = NULL; |
| | 60 | static char *procfs_filename = "procfs_trace"; |
| | 61 | |
| | 62 | static void |
| | 63 | prepare_to_trace (void) |
| | 64 | { |
| | 65 | if (procfs_trace) /* if procfs tracing turned on */ |
| | 66 | if (procfs_file == NULL) /* if output file not yet open */ |
| | 67 | if (procfs_filename != NULL) /* if output filename known */ |
| | 68 | procfs_file = fopen (procfs_filename, "a"); /* open output file */ |
| | 69 | } |
| | 70 | |
| | 71 | static void |
| | 72 | set_procfs_trace_cmd (args, from_tty, c) |
| | 73 | char *args; |
| | 74 | int from_tty; |
| | 75 | struct cmd_list_element *c; |
| | 76 | { |
| | 77 | #if 0 /* not sure what I might actually need to do here, if anything */ |
| | 78 | if (procfs_file) |
| | 79 | fflush (procfs_file); |
| | 80 | #endif |
| | 81 | } |
| | 82 | |
| | 83 | static void |
| | 84 | set_procfs_file_cmd (args, from_tty, c) |
| | 85 | char *args; |
| | 86 | int from_tty; |
| | 87 | struct cmd_list_element *c; |
| | 88 | { |
| | 89 | /* Just changed the filename for procfs tracing. |
| | 90 | If a file was already open, close it. */ |
| | 91 | if (procfs_file) |
| | 92 | fclose (procfs_file); |
| | 93 | procfs_file = NULL; |
| | 94 | } |
| | 95 | |
| | 96 | |
| | 97 | #ifndef NEW_PROC_API |
| | 98 | |
| | 99 | static struct trans ioctl_table[] = { |
| | 100 | #ifdef PIOCACINFO /* irix */ |
| | 101 | { PIOCACINFO, "PIOCACINFO", "get process account info" }, |
| | 102 | #endif |
| | 103 | { PIOCACTION, "PIOCACTION", "get signal action structs" }, |
| | 104 | #ifdef PIOCARGUMENTS /* osf */ |
| | 105 | { PIOCARGUMENTS, "PIOCARGUMENTS", "command line args" }, |
| | 106 | #endif |
| | 107 | #ifdef PIOCAUXV /* solaris aux vectors */ |
| | 108 | { PIOCAUXV, "PIOCAUXV", "get aux vector" }, |
| | 109 | { PIOCNAUXV, "PIOCNAUXV", "get number of aux vector entries" }, |
| | 110 | #endif /* AUXV */ |
| | 111 | { PIOCCFAULT, "PIOCCFAULT", "clear current fault" }, |
| | 112 | { PIOCCRED, "PIOCCRED", "get process credentials" }, |
| | 113 | #ifdef PIOCENEVCTRS /* irix event counters */ |
| | 114 | { PIOCENEVCTRS, "PIOCENEVCTRS", "acquire and start event counters" }, |
| | 115 | { PIOCGETEVCTRL, "PIOCGETEVCTRL", "get control info of event counters" }, |
| | 116 | { PIOCGETEVCTRS, "PIOCGETEVCTRS", "dump event counters" }, |
| | 117 | { PIOCGETPREVCTRS, "PIOCGETPREVCTRS", "dump event counters & prusage info" }, |
| | 118 | { PIOCRELEVCTRS, "PIOCRELEVCTRS", "release/stop event counters" }, |
| | 119 | { PIOCSETEVCTRL, "PIOCSETEVCTRL", "set control info of event counters" }, |
| | 120 | { PIOCGETPTIMER, "PIOCGETPTIMER", "get process timers" }, |
| | 121 | #endif /* irix event counters */ |
| | 122 | { PIOCGENTRY, "PIOCGENTRY", "get traced syscall entry set" }, |
| | 123 | #if defined (PIOCGETPR) |
| | 124 | { PIOCGETPR, "PIOCGETPR", "read struct proc" }, |
| | 125 | #endif |
| | 126 | #if defined (PIOCGETU) |
| | 127 | { PIOCGETU, "PIOCGETU", "read user area" }, |
| | 128 | #endif |
| | 129 | #if defined (PIOCGETUTK) && (defined(KERNEL) || defined(SHOW_UTT)) /* osf */ |
| | 130 | { PIOCGETUTK, "PIOCGETUTK", "get the utask struct" }, |
| | 131 | #endif |
| | 132 | { PIOCGEXIT, "PIOCGEXIT", "get traced syscall exit set" }, |
| | 133 | { PIOCGFAULT, "PIOCGFAULT", "get traced fault set" }, |
| | 134 | #ifdef PIOCGFPCR /* osf */ |
| | 135 | { PIOCGFPCR, "PIOCGFPCR", "get FP control register" }, |
| | 136 | { PIOCSFPCR, "PIOCSFPCR", "set FP conrtol register" }, |
| | 137 | #endif |
| | 138 | { PIOCGFPREG, "PIOCGFPREG", "get floating point registers" }, |
| | 139 | { PIOCGHOLD, "PIOCGHOLD", "get held signal set" }, |
| | 140 | { PIOCGREG, "PIOCGREG", "get general registers" }, |
| | 141 | { PIOCGROUPS, "PIOCGROUPS", "get supplementary groups" }, |
| | 142 | #ifdef PIOCGSPCACT /* osf */ |
| | 143 | { PIOCGSPCACT, "PIOCGSPCACT", "get special action" }, |
| | 144 | { PIOCSSPCACT, "PIOCSSPCACT", "set special action" }, |
| | 145 | #endif |
| | 146 | { PIOCGTRACE, "PIOCGTRACE", "get traced signal set" }, |
| | 147 | #ifdef PIOCGWATCH /* irix watchpoints */ |
| | 148 | { PIOCGWATCH, "PIOCGWATCH", "get watchpoint" }, |
| | 149 | { PIOCSWATCH, "PIOCSWATCH", "set watchpoint" }, |
| | 150 | { PIOCNWATCH, "PIOCNWATCH", "get number of watchpoints" }, |
| | 151 | #endif /* irix watchpoints */ |
| | 152 | #ifdef PIOCGWIN /* solaris sparc */ |
| | 153 | { PIOCGWIN, "PIOCGWIN", "get gwindows_t" }, |
| | 154 | #endif |
| | 155 | #ifdef PIOCGXREG /* solaris sparc extra regs */ |
| | 156 | { PIOCGXREGSIZE, "PIOCXREGSIZE", "get extra register state size" }, |
| | 157 | { PIOCGXREG, "PIOCGXREG", "get extra register state" }, |
| | 158 | { PIOCSXREG, "PIOCSXREG", "set extra register state" }, |
| | 159 | #endif /* XREG */ |
| | 160 | { PIOCKILL, "PIOCKILL", "send signal" }, |
| | 161 | #ifdef PIOCLDT /* solaris i386 */ |
| | 162 | { PIOCLDT, "PIOCLDT", "get LDT" }, |
| | 163 | { PIOCNLDT, "PIOCNLDT", "get number of LDT entries" }, |
| | 164 | #endif |
| | 165 | #ifdef PIOCLSTATUS /* solaris and unixware */ |
| | 166 | { PIOCLSTATUS, "PIOCLSTATUS", "get status of all lwps" }, |
| | 167 | { PIOCLUSAGE, "PIOCLUSAGE", "get resource usage of all lwps" }, |
| | 168 | { PIOCOPENLWP, "PIOCOPENLWP", "get lwp file descriptor" }, |
| | 169 | { PIOCLWPIDS, "PIOCLWPIDS", "get lwp identifiers" }, |
| | 170 | #endif /* LWP */ |
| | 171 | { PIOCMAP, "PIOCMAP", "get memory map information" }, |
| | 172 | { PIOCMAXSIG, "PIOCMAXSIG", "get max signal number" }, |
| | 173 | { PIOCNICE, "PIOCNICE", "set nice priority" }, |
| | 174 | { PIOCNMAP, "PIOCNMAP", "get number of memory mappings" }, |
| | 175 | { PIOCOPENM, "PIOCOPENM", "open mapped object for reading" }, |
| | 176 | #ifdef PIOCOPENMOBS /* osf */ |
| | 177 | { PIOCOPENMOBS, "PIOCOPENMOBS", "open mapped object" }, |
| | 178 | #endif |
| | 179 | #ifdef PIOCOPENPD /* solaris */ |
| | 180 | { PIOCOPENPD, "PIOCOPENPD", "get page data file descriptor" }, |
| | 181 | #endif |
| | 182 | { PIOCPSINFO, "PIOCPSINFO", "get ps(1) information" }, |
| | 183 | { PIOCRESET, "PIOCRESET", "reset process flags" }, |
| | 184 | { PIOCRFORK, "PIOCRFORK", "reset inherit-on-fork flag" }, |
| | 185 | { PIOCRRLC, "PIOCRRLC", "reset run-on-last-close flag" }, |
| | 186 | { PIOCRUN, "PIOCRUN", "make process runnable" }, |
| | 187 | #ifdef PIOCSAVECCNTRS /* irix */ |
| | 188 | { PIOCSAVECCNTRS, "PIOCSAVECCNTRS", "parent gets child cntrs" }, |
| | 189 | #endif |
| | 190 | { PIOCSENTRY, "PIOCSENTRY", "set traced syscall entry set" }, |
| | 191 | { PIOCSET, "PIOCSET", "set process flags" }, |
| | 192 | { PIOCSEXIT, "PIOCSEXIT", "set traced syscall exit set" }, |
| | 193 | { PIOCSFAULT, "PIOCSFAULT", "set traced fault set" }, |
| | 194 | { PIOCSFORK, "PIOCSFORK", "set inherit-on-fork flag" }, |
| | 195 | { PIOCSFPREG, "PIOCSFPREG", "set floating point registers" }, |
| | 196 | { PIOCSHOLD, "PIOCSHOLD", "set held signal set" }, |
| | 197 | { PIOCSREG, "PIOCSREG", "set general registers" }, |
| | 198 | { PIOCSRLC, "PIOCSRLC", "set run-on-last-close flag" }, |
| | 199 | { PIOCSSIG, "PIOCSSIG", "set current signal" }, |
| | 200 | { PIOCSTATUS, "PIOCSTATUS", "get process status" }, |
| | 201 | { PIOCSTOP, "PIOCSTOP", "post stop request" }, |
| | 202 | { PIOCSTRACE, "PIOCSTRACE", "set traced signal set" }, |
| | 203 | { PIOCUNKILL, "PIOCUNKILL", "delete a signal" }, |
| | 204 | #ifdef PIOCUSAGE /* solaris */ |
| | 205 | { PIOCUSAGE, "PIOCUSAGE", "get resource usage" }, |
| | 206 | #endif |
| | 207 | { PIOCWSTOP, "PIOCWSTOP", "wait for process to stop" }, |
| | 208 | |
| | 209 | #ifdef PIOCNTHR /* osf threads */ |
| | 210 | { PIOCNTHR, "PIOCNTHR", "get thread count" }, |
| | 211 | { PIOCRTINH, "PIOCRTINH", "reset inherit-on-thread-creation" }, |
| | 212 | { PIOCSTINH, "PIOCSTINH", "set inherit-on-thread-creation" }, |
| | 213 | { PIOCTLIST, "PIOCTLIST", "get thread ids" }, |
| | 214 | { PIOCXPTH, "PIOCXPTH", "translate port to thread handle" }, |
| | 215 | { PIOCTRUN, "PIOCTRUN", "make thread runnable" }, |
| | 216 | { PIOCTSTATUS, "PIOCTSTATUS", "get thread status" }, |
| | 217 | { PIOCTSTOP, "PIOCTSTOP", "stop a thread" }, |
| | 218 | /* ... TGTRACE TSTRACE TSSIG TKILL TUNKILL TCFAULT TGFAULT TSFAULT |
| | 219 | TGFPREG TSFPREG TGREG TSREG TACTION TTERM TABRUN TGENTRY TSENTRY |
| | 220 | TGEXIT TSEXIT TSHOLD ... thread functions */ |
| | 221 | #endif /* osf threads */ |
| | 222 | { -1, NULL, NULL } |
| | 223 | }; |
| | 224 | |
| | 225 | int |
| | 226 | ioctl_with_trace (fd, opcode, ptr, file, line) |
| | 227 | int fd; |
| | 228 | long opcode; |
| | 229 | void *ptr; |
| | 230 | char *file; |
| | 231 | int line; |
| | 232 | { |
| | 233 | int i, ret, arg1; |
| | 234 | |
| | 235 | prepare_to_trace (); |
| | 236 | |
| | 237 | if (procfs_trace) |
| | 238 | { |
| | 239 | for (i = 0; ioctl_table[i].name != NULL; i++) |
| | 240 | if (ioctl_table[i].value == opcode) |
| | 241 | break; |
| | 242 | |
| | 243 | if (info_verbose) |
| | 244 | fprintf (procfs_file ? procfs_file : stdout, |
| | 245 | "%s:%d -- ", file, line); |
| | 246 | switch (opcode) { |
| | 247 | case PIOCSET: |
| | 248 | arg1 = ptr ? *(long *) ptr : 0; |
| | 249 | fprintf (procfs_file ? procfs_file : stdout, |
| | 250 | "ioctl (PIOCSET, %s) %s\n", |
| | 251 | arg1 == PR_FORK ? "PR_FORK" : |
| | 252 | arg1 == PR_RLC ? "PR_RLC" : |
| | 253 | #ifdef PR_ASYNC |
| | 254 | arg1 == PR_ASYNC ? "PR_ASYNC" : |
| | 255 | #endif |
| | 256 | "<unknown flag>", |
| | 257 | info_verbose ? ioctl_table[i].desc : ""); |
| | 258 | break; |
| | 259 | case PIOCRESET: |
| | 260 | arg1 = ptr ? *(long *) ptr : 0; |
| | 261 | fprintf (procfs_file ? procfs_file : stdout, |
| | 262 | "ioctl (PIOCRESET, %s) %s\n", |
| | 263 | arg1 == PR_FORK ? "PR_FORK" : |
| | 264 | arg1 == PR_RLC ? "PR_RLC" : |
| | 265 | #ifdef PR_ASYNC |
| | 266 | arg1 == PR_ASYNC ? "PR_ASYNC" : |
| | 267 | #endif |
| | 268 | "<unknown flag>", |
| | 269 | info_verbose ? ioctl_table[i].desc : ""); |
| | 270 | break; |
| | 271 | case PIOCSTRACE: |
| | 272 | fprintf (procfs_file ? procfs_file : stdout, |
| | 273 | "ioctl (PIOCSTRACE) "); |
| | 274 | proc_prettyfprint_signalset (procfs_file ? procfs_file : stdout, |
| | 275 | (sigset_t *) ptr, 0); |
| | 276 | break; |
| | 277 | case PIOCSFAULT: |
| | 278 | fprintf (procfs_file ? procfs_file : stdout, |
| | 279 | "ioctl (%s) ", |
| | 280 | opcode == PIOCSFAULT ? "PIOCSFAULT" : "PIOCGFAULT"); |
| | 281 | proc_prettyfprint_faultset (procfs_file ? procfs_file : stdout, |
| | 282 | (fltset_t *) ptr, 0); |
| | 283 | break; |
| | 284 | case PIOCSENTRY: |
| | 285 | fprintf (procfs_file ? procfs_file : stdout, |
| | 286 | "ioctl (%s) ", |
| | 287 | opcode == PIOCSENTRY ? "PIOCSENTRY" : "PIOCGENTRY"); |
| | 288 | proc_prettyfprint_syscalls (procfs_file ? procfs_file : stdout, |
| | 289 | (sysset_t *) ptr, 0); |
| | 290 | break; |
| | 291 | case PIOCSEXIT: |
| | 292 | fprintf (procfs_file ? procfs_file : stdout, |
| | 293 | "ioctl (%s) ", |
| | 294 | opcode == PIOCSEXIT ? "PIOCSEXIT" : "PIOCGEXIT"); |
| | 295 | proc_prettyfprint_syscalls (procfs_file ? procfs_file : stdout, |
| | 296 | (sysset_t *) ptr, 0); |
| | 297 | break; |
| | 298 | case PIOCSHOLD: |
| | 299 | fprintf (procfs_file ? procfs_file : stdout, |
| | 300 | "ioctl (%s) ", |
| | 301 | opcode == PIOCSHOLD ? "PIOCSHOLD" : "PIOCGHOLD"); |
| | 302 | proc_prettyfprint_signalset (procfs_file ? procfs_file : stdout, |
| | 303 | (sigset_t *) ptr, 0); |
| | 304 | break; |
| | 305 | case PIOCSSIG: |
| | 306 | fprintf (procfs_file ? procfs_file : stdout, |
| | 307 | "ioctl (PIOCSSIG) "); |
| | 308 | proc_prettyfprint_signal (procfs_file ? procfs_file : stdout, |
| | 309 | ptr ? ((siginfo_t *) ptr)->si_signo : 0, |
| | 310 | 0); |
| | 311 | fprintf (procfs_file ? procfs_file : stdout, "\n"); |
| | 312 | break; |
| | 313 | case PIOCRUN: |
| | 314 | fprintf (procfs_file ? procfs_file : stdout, |
| | 315 | "ioctl (PIOCRUN) "); |
| | 316 | |
| | 317 | arg1 = ptr ? *(long *) ptr : 0; |
| | 318 | if (arg1 & PRCSIG) |
| | 319 | fprintf (procfs_file ? procfs_file : stdout, "clearSig "); |
| | 320 | if (arg1 & PRCFAULT) |
| | 321 | fprintf (procfs_file ? procfs_file : stdout, "clearFlt "); |
| | 322 | if (arg1 & PRSTRACE) |
| | 323 | fprintf (procfs_file ? procfs_file : stdout, "setTrace "); |
| | 324 | if (arg1 & PRSHOLD) |
| | 325 | fprintf (procfs_file ? procfs_file : stdout, "setHold "); |
| | 326 | if (arg1 & PRSFAULT) |
| | 327 | fprintf (procfs_file ? procfs_file : stdout, "setFlt "); |
| | 328 | if (arg1 & PRSVADDR) |
| | 329 | fprintf (procfs_file ? procfs_file : stdout, "setVaddr "); |
| | 330 | if (arg1 & PRSTEP) |
| | 331 | fprintf (procfs_file ? procfs_file : stdout, "step "); |
| | 332 | if (arg1 & PRSABORT) |
| | 333 | fprintf (procfs_file ? procfs_file : stdout, "syscallAbort "); |
| | 334 | if (arg1 & PRSTOP) |
| | 335 | fprintf (procfs_file ? procfs_file : stdout, "stopReq "); |
| | 336 | |
| | 337 | fprintf (procfs_file ? procfs_file : stdout, "\n"); |
| | 338 | break; |
| | 339 | case PIOCKILL: |
| | 340 | fprintf (procfs_file ? procfs_file : stdout, |
| | 341 | "ioctl (PIOCKILL) "); |
| | 342 | proc_prettyfprint_signal (procfs_file ? procfs_file : stdout, |
| | 343 | ptr ? *(long *) ptr : 0, 0); |
| | 344 | fprintf (procfs_file ? procfs_file : stdout, "\n"); |
| | 345 | break; |
| | 346 | #ifdef PIOCSSPCACT |
| | 347 | case PIOCSSPCACT: |
| | 348 | fprintf (procfs_file ? procfs_file : stdout, |
| | 349 | "ioctl (PIOCSSPCACT) "); |
| | 350 | arg1 = ptr ? *(long *) ptr : 0; |
| | 351 | if (arg1 & PRFS_STOPFORK) |
| | 352 | fprintf (procfs_file ? procfs_file : stdout, "stopFork "); |
| | 353 | if (arg1 & PRFS_STOPEXEC) |
| | 354 | fprintf (procfs_file ? procfs_file : stdout, "stopExec "); |
| | 355 | if (arg1 & PRFS_STOPTERM) |
| | 356 | fprintf (procfs_file ? procfs_file : stdout, "stopTerm "); |
| | 357 | if (arg1 & PRFS_STOPTCR) |
| | 358 | fprintf (procfs_file ? procfs_file : stdout, "stopThreadCreate "); |
| | 359 | if (arg1 & PRFS_STOPTTERM) |
| | 360 | fprintf (procfs_file ? procfs_file : stdout, "stopThreadTerm "); |
| | 361 | if (arg1 & PRFS_KOLC) |
| | 362 | fprintf (procfs_file ? procfs_file : stdout, "killOnLastClose "); |
| | 363 | fprintf (procfs_file ? procfs_file : stdout, "\n"); |
| | 364 | break; |
| | 365 | #endif /* PIOCSSPCACT */ |
| | 366 | default: |
| | 367 | if (ioctl_table[i].name) |
| | 368 | fprintf (procfs_file ? procfs_file : stdout, |
| | 369 | "ioctl (%s) %s\n", |
| | 370 | ioctl_table[i].name, |
| | 371 | info_verbose ? ioctl_table[i].desc : ""); |
| | 372 | else |
| | 373 | fprintf (procfs_file ? procfs_file : stdout, |
| | 374 | "ioctl (<unknown %ld (0x%lx)) \n", opcode, opcode); |
| | 375 | break; |
| | 376 | } |
| | 377 | if (procfs_file) |
| | 378 | fflush (procfs_file); |
| | 379 | } |
| | 380 | errno = 0; |
| | 381 | ret = ioctl (fd, opcode, ptr); |
| | 382 | if (procfs_trace && ret < 0) |
| | 383 | { |
| | 384 | fprintf (procfs_file ? procfs_file : stdout, |
| | 385 | "[ioctl (%s) FAILED! (%s)]\n", |
| | 386 | ioctl_table[i].name != NULL ? |
| | 387 | ioctl_table[i].name : "<unknown>", |
| | 388 | safe_strerror (errno)); |
| | 389 | if (procfs_file) |
| | 390 | fflush (procfs_file); |
| | 391 | } |
| | 392 | |
| | 393 | return ret; |
| | 394 | } |
| | 395 | |
| | 396 | #else /* NEW_PROC_API */ |
| | 397 | |
| | 398 | static struct trans rw_table[] = { |
| | 399 | #ifdef PCAGENT /* solaris */ |
| | 400 | { PCAGENT, "PCAGENT", "create agent lwp with regs from argument" }, |
| | 401 | #endif |
| | 402 | { PCCFAULT, "PCCFAULT", "clear current fault" }, |
| | 403 | #ifdef PCCSIG /* solaris */ |
| | 404 | { PCCSIG, "PCCSIG", "clear current signal" }, |
| | 405 | #endif |
| | 406 | { PCDSTOP, "PCDSTOP", "post stop request" }, |
| | 407 | { PCKILL, "PCKILL", "post a signal" }, |
| | 408 | { PCNICE, "PCNICE", "set nice priority" }, |
| | 409 | #ifdef PCREAD /* solaris */ |
| | 410 | { PCREAD, "PCREAD", "read from the address space" }, |
| | 411 | { PCWRITE, "PCWRITE", "write to the address space" }, |
| | 412 | #endif |
| | 413 | #ifdef PCRESET /* unixware */ |
| | 414 | { PCRESET, "PCRESET", "unset modes" }, |
| | 415 | #endif |
| | 416 | { PCRUN, "PCRUN", "make process/lwp runnable" }, |
| | 417 | #ifdef PCSASRS /* solaris 2.7 only */ |
| | 418 | { PCSASRS, "PCSASRS", "set ancillary state registers" }, |
| | 419 | #endif |
| | 420 | #ifdef PCSCRED /* solaris */ |
| | 421 | { PCSCRED, "PCSCRED", "set process credentials" }, |
| | 422 | #endif |
| | 423 | { PCSENTRY, "PCSENTRY", "set traced syscall entry set" }, |
| | 424 | { PCSET, "PCSET", "set modes" }, |
| | 425 | { PCSEXIT, "PCSEXIT", "set traced syscall exit set" }, |
| | 426 | { PCSFAULT, "PCSFAULT", "set traced fault set" }, |
| | 427 | { PCSFPREG, "PCSFPREG", "set floating point registers" }, |
| | 428 | { PCSHOLD, "PCSHOLD", "set signal mask" }, |
| | 429 | { PCSREG, "PCSREG", "set general registers" }, |
| | 430 | { PCSSIG, "PCSSIG", "set current signal" }, |
| | 431 | { PCSTOP, "PCSTOP", "post stop request and wait" }, |
| | 432 | { PCSTRACE, "PCSTRACE", "set traced signal set" }, |
| | 433 | #ifdef PCSVADDR /* solaris */ |
| | 434 | { PCSVADDR, "PCSVADDR", "set pc virtual address" }, |
| | 435 | #endif |
| | 436 | #ifdef PCSXREG /* solaris sparc only */ |
| | 437 | { PCSXREG, "PCSXREG", "set extra registers" }, |
| | 438 | #endif |
| | 439 | #ifdef PCTWSTOP /* solaris */ |
| | 440 | { PCTWSTOP, "PCTWSTOP", "wait for stop, with timeout arg" }, |
| | 441 | #endif |
| | 442 | { PCUNKILL, "PCUNKILL", "delete a pending signal" }, |
| | 443 | #ifdef PCUNSET /* solaris */ |
| | 444 | { PCUNSET, "PCUNSET", "unset modes" }, |
| | 445 | #endif |
| | 446 | #ifdef PCWATCH /* solaris */ |
| | 447 | { PCWATCH, "PCWATCH", "set/unset watched memory area" }, |
| | 448 | #endif |
| | 449 | { PCWSTOP, "PCWSTOP", "wait for process/lwp to stop, no timeout" }, |
| | 450 | { 0, NULL, NULL } |
| | 451 | }; |
| | 452 | |
| | 453 | static off_t lseek_offset; |
| | 454 | |
| | 455 | int |
| | 456 | write_with_trace (fd, varg, len, file, line) |
| | 457 | int fd; |
| | 458 | void *varg; |
| | 459 | size_t len; |
| | 460 | char *file; |
| | 461 | int line; |
| | 462 | { |
| | 463 | int i; |
| | 464 | int ret; |
| | 465 | long *arg = (long *) varg; |
| | 466 | |
| | 467 | prepare_to_trace (); |
| | 468 | if (procfs_trace) |
| | 469 | { |
| | 470 | long opcode = arg[0]; |
| | 471 | for (i = 0; rw_table[i].name != NULL; i++) |
| | 472 | if (rw_table[i].value == opcode) |
| | 473 | break; |
| | 474 | |
| | 475 | if (info_verbose) |
| | 476 | fprintf (procfs_file ? procfs_file : stdout, |
| | 477 | "%s:%d -- ", file, line); |
| | 478 | switch (opcode) { |
| | 479 | case PCSET: |
| | 480 | fprintf (procfs_file ? procfs_file : stdout, |
| | 481 | "write (PCSET, %s) %s\n", |
| | 482 | arg[1] == PR_FORK ? "PR_FORK" : |
| | 483 | arg[1] == PR_RLC ? "PR_RLC" : |
| | 484 | #ifdef PR_ASYNC |
| | 485 | arg[1] == PR_ASYNC ? "PR_ASYNC" : |
| | 486 | #endif |
| | 487 | "<unknown flag>", |
| | 488 | info_verbose ? rw_table[i].desc : ""); |
| | 489 | break; |
| | 490 | #ifdef PCUNSET |
| | 491 | case PCUNSET: |
| | 492 | #endif |
| | 493 | #ifdef PCRESET |
| | 494 | case PCRESET: |
| | 495 | #endif |
| | 496 | fprintf (procfs_file ? procfs_file : stdout, |
| | 497 | "write (PCRESET, %s) %s\n", |
| | 498 | arg[1] == PR_FORK ? "PR_FORK" : |
| | 499 | arg[1] == PR_RLC ? "PR_RLC" : |
| | 500 | #ifdef PR_ASYNC |
| | 501 | arg[1] == PR_ASYNC ? "PR_ASYNC" : |
| | 502 | #endif |
| | 503 | "<unknown flag>", |
| | 504 | info_verbose ? rw_table[i].desc : ""); |
| | 505 | break; |
| | 506 | case PCSTRACE: |
| | 507 | fprintf (procfs_file ? procfs_file : stdout, |
| | 508 | "write (PCSTRACE) "); |
| | 509 | proc_prettyfprint_signalset (procfs_file ? procfs_file : stdout, |
| | 510 | (sigset_t *) &arg[1], 0); |
| | 511 | break; |
| | 512 | case PCSFAULT: |
| | 513 | fprintf (procfs_file ? procfs_file : stdout, |
| | 514 | "write (PCSFAULT) "); |
| | 515 | proc_prettyfprint_faultset (procfs_file ? procfs_file : stdout, |
| | 516 | (fltset_t *) &arg[1], 0); |
| | 517 | break; |
| | 518 | case PCSENTRY: |
| | 519 | fprintf (procfs_file ? procfs_file : stdout, |
| | 520 | "write (PCSENTRY) "); |
| | 521 | proc_prettyfprint_syscalls (procfs_file ? procfs_file : stdout, |
| | 522 | (sysset_t *) &arg[1], 0); |
| | 523 | break; |
| | 524 | case PCSEXIT: |
| | 525 | fprintf (procfs_file ? procfs_file : stdout, |
| | 526 | "write (PCSEXIT) "); |
| | 527 | proc_prettyfprint_syscalls (procfs_file ? procfs_file : stdout, |
| | 528 | (sysset_t *) &arg[1], 0); |
| | 529 | break; |
| | 530 | case PCSHOLD: |
| | 531 | fprintf (procfs_file ? procfs_file : stdout, |
| | 532 | "write (PCSHOLD) "); |
| | 533 | proc_prettyfprint_signalset (procfs_file ? procfs_file : stdout, |
| | 534 | (sigset_t *) &arg[1], 0); |
| | 535 | break; |
| | 536 | case PCSSIG: |
| | 537 | fprintf (procfs_file ? procfs_file : stdout, |
| | 538 | "write (PCSSIG) "); |
| | 539 | proc_prettyfprint_signal (procfs_file ? procfs_file : stdout, |
| | 540 | arg[1] ? ((siginfo_t *) &arg[1])->si_signo |
| | 541 | : 0, |
| | 542 | 0); |
| | 543 | fprintf (procfs_file ? procfs_file : stdout, "\n"); |
| | 544 | break; |
| | 545 | case PCRUN: |
| | 546 | fprintf (procfs_file ? procfs_file : stdout, |
| | 547 | "write (PCRUN) "); |
| | 548 | if (arg[1] & PRCSIG) |
| | 549 | fprintf (procfs_file ? procfs_file : stdout, "clearSig "); |
| | 550 | if (arg[1] & PRCFAULT) |
| | 551 | fprintf (procfs_file ? procfs_file : stdout, "clearFlt "); |
| | 552 | if (arg[1] & PRSTEP) |
| | 553 | fprintf (procfs_file ? procfs_file : stdout, "step "); |
| | 554 | if (arg[1] & PRSABORT) |
| | 555 | fprintf (procfs_file ? procfs_file : stdout, "syscallAbort "); |
| | 556 | if (arg[1] & PRSTOP) |
| | 557 | fprintf (procfs_file ? procfs_file : stdout, "stopReq "); |
| | 558 | |
| | 559 | fprintf (procfs_file ? procfs_file : stdout, "\n"); |
| | 560 | break; |
| | 561 | case PCKILL: |
| | 562 | fprintf (procfs_file ? procfs_file : stdout, |
| | 563 | "write (PCKILL) "); |
| | 564 | proc_prettyfprint_signal (procfs_file ? procfs_file : stdout, |
| | 565 | arg[1], 0); |
| | 566 | fprintf (procfs_file ? procfs_file : stdout, "\n"); |
| | 567 | break; |
| | 568 | default: |
| | 569 | { |
| | 570 | static unsigned char break_insn[] = BREAKPOINT; |
| | 571 | |
| | 572 | if (len == sizeof (break_insn) && |
| | 573 | memcmp (arg, &break_insn, len) == 0) |
| | 574 | fprintf (procfs_file ? procfs_file : stdout, |
| | 575 | "write (<breakpoint at 0x%08lx>) \n", |
| | 576 | (unsigned long) lseek_offset); |
| | 577 | else if (rw_table[i].name) |
| | 578 | fprintf (procfs_file ? procfs_file : stdout, |
| | 579 | "write (%s) %s\n", |
| | 580 | rw_table[i].name, |
| | 581 | info_verbose ? rw_table[i].desc : ""); |
| | 582 | else |
| | 583 | { |
| | 584 | if (lseek_offset != -1) |
| | 585 | fprintf (procfs_file ? procfs_file : stdout, |
| | 586 | "write (<unknown>, %lud bytes at 0x%08lx) \n", |
| | 587 | (unsigned long) len, (unsigned long) lseek_offset); |
| | 588 | else |
| | 589 | fprintf (procfs_file ? procfs_file : stdout, |
| | 590 | "write (<unknown>, %lud bytes) \n", |
| | 591 | (unsigned long) len); |
| | 592 | } |
| | 593 | break; |
| | 594 | } |
| | 595 | } |
| | 596 | if (procfs_file) |
| | 597 | fflush (procfs_file); |
| | 598 | } |
| | 599 | errno = 0; |
| | 600 | ret = write (fd, (void *) arg, len); |
| | 601 | if (procfs_trace && ret != len) |
| | 602 | { |
| | 603 | fprintf (procfs_file ? procfs_file : stdout, |
| | 604 | "[write (%s) FAILED! (%s)]\n", |
| | 605 | rw_table[i].name != NULL ? |
| | 606 | rw_table[i].name : "<unknown>", |
| | 607 | safe_strerror (errno)); |
| | 608 | if (procfs_file) |
| | 609 | fflush (procfs_file); |
| | 610 | } |
| | 611 | |
| | 612 | lseek_offset = -1; |
| | 613 | return ret; |
| | 614 | } |
| | 615 | |
| | 616 | off_t |
| | 617 | lseek_with_trace (fd, offset, whence, file, line) |
| | 618 | int fd; |
| | 619 | off_t offset; |
| | 620 | int whence; |
| | 621 | char *file; |
| | 622 | int line; |
| | 623 | { |
| | 624 | off_t ret; |
| | 625 | |
| | 626 | prepare_to_trace (); |
| | 627 | errno = 0; |
| | 628 | ret = lseek (fd, offset, whence); |
| | 629 | lseek_offset = ret; |
| | 630 | if (procfs_trace && (ret == -1 || errno != 0)) |
| | 631 | { |
| | 632 | fprintf (procfs_file ? procfs_file : stdout, |
| | 633 | "[lseek (0x%08lx) FAILED! (%s)]\n", |
| | 634 | (unsigned long) offset, safe_strerror (errno)); |
| | 635 | if (procfs_file) |
| | 636 | fflush (procfs_file); |
| | 637 | } |
| | 638 | |
| | 639 | return ret; |
| | 640 | } |
| | 641 | |
| | 642 | #endif /* NEW_PROC_API */ |
| | 643 | |
| | 644 | int |
| | 645 | open_with_trace (filename, mode, file, line) |
| | 646 | char *filename; |
| | 647 | int mode; |
| | 648 | char *file; |
| | 649 | int line; |
| | 650 | { |
| | 651 | int ret; |
| | 652 | |
| | 653 | prepare_to_trace (); |
| | 654 | errno = 0; |
| | 655 | ret = open (filename, mode); |
| | 656 | if (procfs_trace) |
| | 657 | { |
| | 658 | if (info_verbose) |
| | 659 | fprintf (procfs_file ? procfs_file : stdout, |
| | 660 | "%s:%d -- ", file, line); |
| | 661 | |
| | 662 | if (errno) |
| | 663 | { |
| | 664 | fprintf (procfs_file ? procfs_file : stdout, |
| | 665 | "[open FAILED! (%s) line %d]\\n", |
| | 666 | safe_strerror (errno), line); |
| | 667 | } |
| | 668 | else |
| | 669 | { |
| | 670 | fprintf (procfs_file ? procfs_file : stdout, |
| | 671 | "%d = open (%s, ", ret, filename); |
| | 672 | if (mode == O_RDONLY) |
| | 673 | fprintf (procfs_file ? procfs_file : stdout, "O_RDONLY) %d\n", |
| | 674 | line); |
| | 675 | else if (mode == O_WRONLY) |
| | 676 | fprintf (procfs_file ? procfs_file : stdout, "O_WRONLY) %d\n", |
| | 677 | line); |
| | 678 | else if (mode == O_RDWR) |
| | 679 | fprintf (procfs_file ? procfs_file : stdout, "O_RDWR) %d\n", |
| | 680 | line); |
| | 681 | } |
| | 682 | if (procfs_file) |
| | 683 | fflush (procfs_file); |
| | 684 | } |
| | 685 | |
| | 686 | return ret; |
| | 687 | } |
| | 688 | |
| | 689 | int |
| | 690 | close_with_trace (fd, file, line) |
| | 691 | int fd; |
| | 692 | char *file; |
| | 693 | int line; |
| | 694 | { |
| | 695 | int ret; |
| | 696 | |
| | 697 | prepare_to_trace (); |
| | 698 | errno = 0; |
| | 699 | ret = close (fd); |
| | 700 | if (procfs_trace) |
| | 701 | { |
| | 702 | if (info_verbose) |
| | 703 | fprintf (procfs_file ? procfs_file : stdout, |
| | 704 | "%s:%d -- ", file, line); |
| | 705 | if (errno) |
| | 706 | fprintf (procfs_file ? procfs_file : stdout, |
| | 707 | "[close FAILED! (%s)]\n", safe_strerror (errno)); |
| | 708 | else |
| | 709 | fprintf (procfs_file ? procfs_file : stdout, |
| | 710 | "%d = close (%d)\n", ret, fd); |
| | 711 | if (procfs_file) |
| | 712 | fflush (procfs_file); |
| | 713 | } |
| | 714 | |
| | 715 | return ret; |
| | 716 | } |
| | 717 | |
| | 718 | pid_t |
| | 719 | wait_with_trace (wstat, file, line) |
| | 720 | int *wstat; |
| | 721 | char *file; |
| | 722 | int line; |
| | 723 | { |
| | 724 | int ret, lstat = 0; |
| | 725 | |
| | 726 | prepare_to_trace (); |
| | 727 | if (procfs_trace) |
| | 728 | { |
| | 729 | if (info_verbose) |
| | 730 | fprintf (procfs_file ? procfs_file : stdout, |
| | 731 | "%s:%d -- ", file, line); |
| | 732 | fprintf (procfs_file ? procfs_file : stdout, |
| | 733 | "wait (line %d) ", line); |
| | 734 | if (procfs_file) |
| | 735 | fflush (procfs_file); |
| | 736 | } |
| | 737 | errno = 0; |
| | 738 | ret = wait (&lstat); |
| | 739 | if (procfs_trace) |
| | 740 | { |
| | 741 | if (errno) |
| | 742 | fprintf (procfs_file ? procfs_file : stdout, |
| | 743 | "[wait FAILED! (%s)]\n", safe_strerror (errno)); |
| | 744 | else |
| | 745 | fprintf (procfs_file ? procfs_file : stdout, |
| | 746 | "returned pid %d, status 0x%x\n", ret, lstat); |
| | 747 | if (procfs_file) |
| | 748 | fflush (procfs_file); |
| | 749 | } |
| | 750 | if (wstat) |
| | 751 | *wstat = lstat; |
| | 752 | |
| | 753 | return ret; |
| | 754 | } |
| | 755 | |
| | 756 | void |
| | 757 | procfs_note (msg, file, line) |
| | 758 | char *msg; |
| | 759 | char *file; |
| | 760 | int line; |
| | 761 | { |
| | 762 | prepare_to_trace (); |
| | 763 | if (procfs_trace) |
| | 764 | { |
| | 765 | if (info_verbose) |
| | 766 | fprintf (procfs_file ? procfs_file : stdout, |
| | 767 | "%s:%d -- ", file, line); |
| | 768 | fprintf (procfs_file ? procfs_file : stdout, msg); |
| | 769 | if (procfs_file) |
| | 770 | fflush (procfs_file); |
| | 771 | } |
| | 772 | } |
| | 773 | |
| | 774 | void |
| | 775 | proc_prettyfprint_status (flags, why, what, thread) |
| | 776 | long flags; |
| | 777 | int why; |
| | 778 | int what; |
| | 779 | int thread; |
| | 780 | { |
| | 781 | prepare_to_trace (); |
| | 782 | if (procfs_trace) |
| | 783 | { |
| | 784 | if (thread) |
| | 785 | fprintf (procfs_file ? procfs_file : stdout, |
| | 786 | "Thread %d: ", thread); |
| | 787 | |
| | 788 | proc_prettyfprint_flags (procfs_file ? procfs_file : stdout, |
| | 789 | flags, 0); |
| | 790 | |
| | 791 | if (flags & (PR_STOPPED | PR_ISTOP)) |
| | 792 | proc_prettyfprint_why (procfs_file ? procfs_file : stdout, |
| | 793 | why, what, 0); |
| | 794 | if (procfs_file) |
| | 795 | fflush (procfs_file); |
| | 796 | } |
| | 797 | } |
| | 798 | |
| | 799 | |
| | 800 | void |
| | 801 | _initialize_proc_api () |
| | 802 | { |
| | 803 | struct cmd_list_element *c; |
| | 804 | |
| | 805 | c = add_set_cmd ("procfs-trace", no_class, |
| | 806 | var_boolean, (char *) &procfs_trace, |
| | 807 | "Set tracing for /proc api calls.\n", &setlist); |
| | 808 | |
| | 809 | add_show_from_set (c, &showlist); |
| | 810 | c->function.sfunc = set_procfs_trace_cmd; |
| | 811 | |
| | 812 | c = add_set_cmd ("procfs-file", no_class, var_filename, |
| | 813 | (char *) &procfs_filename, |
| | 814 | "Set filename for /proc tracefile.\n", &setlist); |
| | 815 | |
| | 816 | add_show_from_set (c, &showlist); |
| | 817 | c->function.sfunc = set_procfs_file_cmd; |
| | 818 | } |
projects / deliverable / binutils-gdb.git / blame_incremental