From: Rainer Orth Date: Thu, 20 Sep 2018 18:01:05 +0000 (+0200) Subject: More Solaris procfs cleanup X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=c475f569191cc0257bf0959c3475ca08644125b1;p=binutils-gdb.git More Solaris procfs cleanup This procfs.c (and friends) cleanup patch grew along a couple of lines: * First I noticed that PR_MODEL_NATIVE is always defined now that Solaris 10 is the minimum supported version. * Then there was a cleanup that I'd missed when removing support for !NEW_PROC_API, IRIX, and Tru64 UNIX: given that sysset_t is no longer dynamic, there's no need for the special sysset_t_alloc, but we can just use XNEW instead. * Then I found one of those ARI warning mails on gdb-patches, discovered how to run it myself and fixed a large number of the warnings, among them all uses of sprintf. I had to silence the warnings in only 3 instances of the same issue, namely references to LDT in function names which are due to the libthread_db API. * Even so, there were several formatting glitches, like braces around single statements in an if, which I chose to fix while I was at it. The result has been tested on amd64-pc-solaris2.11 and amd64-pc-solaris2.11. * proc-utils.h (PROC_CTL_WORD_TYPE): Remove. * procfs.c: Don't check for PR_MODEL_NATIVE definition. * sparc-sol2-nat.c: Likewise. Remove Linux, __arch64__ references. * sol-thread.c (ps_pdmodel): Don't guard definition. * procfs.c: Fix formatting. * procfs.c (sysset_t_alloc): Remove. (create_procinfo): Use XNEW instead of sysset_t_alloc. (procfs_debug_inferior): Likewise. (procfs_set_exec_trap): Likewise. (proc_set_traced_sysentry): Don't allocate argp dynamically. (proc_set_traced_sysexit): Likewise. * procfs.c (create_procinfo): Use xsnprintf to fix ARI warning. (dead_procinfo): Likewise. (proc_warn): Likewise. (proc_error): Likewise. (proc_get_LDT_entry): Likewise. (do_attach): Likewise. (procfs_target::pid_to_str): Likewise. (iterate_over_mappings): Likewise. * procfs.c (create_procinfo): Fix ARI warning. (proc_get_status): Likewise. (proc_stop_process): Likewise. (proc_run_process): Likewise. (proc_kill): Likewise. (proc_get_LDT_entry): Likewise. (procfs_find_LDT_entry): Likewise. (proc_update_threads): Likewise. (proc_iterate_over_threads): Likewise. (do_attach): Likewise. (procfs_xfer_memory): Likewise. (invalidate_cache): Likewise. (procfs_target::resume): Likewise. (procfs_init_inferior): Likewise. (procfs_set_exec_trap): Likewise. (procfs_target::thread_alive): Likewise. (procfs_target::pid_to_exec_file): Likewise. (iterate_over_mappings): Likewise. (procfs_target::make_corefile_notes): Likewise. * sol-thread.c (sol_thread_target::thread_alive): Likewise. * procfs.c (procfs_find_LDT_entry): Silence ARI warning. (procfs_find_LDT_entry): Likewise. * sol-thread.c (ps_lgetLDT): Likewise. --- diff --git a/gdb/ChangeLog b/gdb/ChangeLog index c767fcd7ca6..88d752b2bfe 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,54 @@ +2018-09-20 Rainer Orth + + * proc-utils.h (PROC_CTL_WORD_TYPE): Remove. + + * procfs.c: Don't check for PR_MODEL_NATIVE definition. + * sparc-sol2-nat.c: Likewise. Remove Linux, __arch64__ references. + * sol-thread.c (ps_pdmodel): Don't guard definition. + + * procfs.c: Fix formatting. + + * procfs.c (sysset_t_alloc): Remove. + (create_procinfo): Use XNEW instead of sysset_t_alloc. + (procfs_debug_inferior): Likewise. + (procfs_set_exec_trap): Likewise. + (proc_set_traced_sysentry): Don't allocate argp dynamically. + (proc_set_traced_sysexit): Likewise. + + * procfs.c (create_procinfo): Use xsnprintf to fix ARI warning. + (dead_procinfo): Likewise. + (proc_warn): Likewise. + (proc_error): Likewise. + (proc_get_LDT_entry): Likewise. + (do_attach): Likewise. + (procfs_target::pid_to_str): Likewise. + (iterate_over_mappings): Likewise. + + * procfs.c (create_procinfo): Fix ARI warning. + (proc_get_status): Likewise. + (proc_stop_process): Likewise. + (proc_run_process): Likewise. + (proc_kill): Likewise. + (proc_get_LDT_entry): Likewise. + (procfs_find_LDT_entry): Likewise. + (proc_update_threads): Likewise. + (proc_iterate_over_threads): Likewise. + (do_attach): Likewise. + (procfs_xfer_memory): Likewise. + (invalidate_cache): Likewise. + (procfs_target::resume): Likewise. + (procfs_init_inferior): Likewise. + (procfs_set_exec_trap): Likewise. + (procfs_target::thread_alive): Likewise. + (procfs_target::pid_to_exec_file): Likewise. + (iterate_over_mappings): Likewise. + (procfs_target::make_corefile_notes): Likewise. + * sol-thread.c (sol_thread_target::thread_alive): Likewise. + + * procfs.c (procfs_find_LDT_entry): Silence ARI warning. + (procfs_find_LDT_entry): Likewise. + * sol-thread.c (ps_lgetLDT): Likewise. + 2018-09-20 Rainer Orth PR tdep/17903 diff --git a/gdb/proc-utils.h b/gdb/proc-utils.h index aa83677cf19..0bad940f224 100644 --- a/gdb/proc-utils.h +++ b/gdb/proc-utils.h @@ -112,8 +112,4 @@ extern void procfs_note (const char *, const char *, int); /* Define the type (and more importantly the width) of the control word used to write to the /proc/PID/ctl file. */ -#if defined (PROC_CTL_WORD_TYPE) -typedef PROC_CTL_WORD_TYPE procfs_ctl_t; -#else typedef long procfs_ctl_t; -#endif diff --git a/gdb/procfs.c b/gdb/procfs.c index 1fd55d3c7fd..6ffe569e690 100644 --- a/gdb/procfs.c +++ b/gdb/procfs.c @@ -141,7 +141,7 @@ public: bool info_proc (const char *, enum info_proc_what) override; -#if defined(PR_MODEL_NATIVE) && (PR_MODEL_NATIVE == PR_MODEL_LP64) +#if PR_MODEL_NATIVE == PR_MODEL_LP64 int auxv_parse (gdb_byte **readptr, gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp) override; @@ -163,7 +163,7 @@ public: static procfs_target the_procfs_target; -#if defined (PR_MODEL_NATIVE) && (PR_MODEL_NATIVE == PR_MODEL_LP64) +#if PR_MODEL_NATIVE == PR_MODEL_LP64 /* When GDB is built as 64-bit application on Solaris, the auxv data is presented in 64-bit format. We need to provide a custom parser to handle that. */ @@ -277,7 +277,6 @@ static void destroy_procinfo (procinfo *p); static void dead_procinfo (procinfo *p, const char *msg, int killp); static int open_procinfo_files (procinfo *p, int which); static void close_procinfo_files (procinfo *p); -static sysset_t *sysset_t_alloc (procinfo *pi); static int iterate_over_mappings (procinfo *pi, find_memory_region_ftype child_func, void *data, @@ -456,7 +455,8 @@ create_procinfo (int pid, int tid) { procinfo *pi, *parent = NULL; - if ((pi = find_procinfo (pid, tid))) + pi = find_procinfo (pid, tid); + if (pi != NULL) return pi; /* Already exists, nothing to do. */ /* Find parent before doing malloc, to save having to cleanup. */ @@ -470,19 +470,20 @@ create_procinfo (int pid, int tid) pi->pid = pid; pi->tid = tid; - pi->saved_entryset = sysset_t_alloc (pi); - pi->saved_exitset = sysset_t_alloc (pi); + pi->saved_entryset = XNEW (sysset_t); + pi->saved_exitset = XNEW (sysset_t); /* Chain into list. */ if (tid == 0) { - sprintf (pi->pathname, MAIN_PROC_NAME_FMT, pid); + xsnprintf (pi->pathname, sizeof (pi->pathname), MAIN_PROC_NAME_FMT, pid); pi->next = procinfo_list; procinfo_list = pi; } else { - sprintf (pi->pathname, "/proc/%d/lwp/%d", pid, tid); + xsnprintf (pi->pathname, sizeof (pi->pathname), "/proc/%d/lwp/%d", + pid, tid); pi->next = parent->thread_list; parent->thread_list = pi; } @@ -573,12 +574,10 @@ dead_procinfo (procinfo *pi, const char *msg, int kill_p) char procfile[80]; if (pi->pathname) - { - print_sys_errmsg (pi->pathname, errno); - } + print_sys_errmsg (pi->pathname, errno); else { - sprintf (procfile, "process %d", pi->pid); + xsnprintf (procfile, sizeof (procfile), "process %d", pi->pid); print_sys_errmsg (procfile, errno); } if (kill_p == KILL) @@ -588,14 +587,6 @@ dead_procinfo (procinfo *pi, const char *msg, int kill_p) error ("%s", msg); } -/* Allocate and (partially) initialize a sysset_t struct. */ - -static sysset_t * -sysset_t_alloc (procinfo *pi) -{ - return (sysset_t *) xmalloc (sizeof (sysset_t)); -} - /* =================== END, STRUCT PROCINFO "MODULE" =================== */ /* =================== /proc "MODULE" =================== */ @@ -623,14 +614,16 @@ static int proc_iterate_over_threads static void proc_warn (procinfo *pi, const char *func, int line) { - sprintf (errmsg, "procfs: %s line %d, %s", func, line, pi->pathname); + xsnprintf (errmsg, sizeof (errmsg), "procfs: %s line %d, %s", + func, line, pi->pathname); print_sys_errmsg (errmsg, errno); } static void proc_error (procinfo *pi, const char *func, int line) { - sprintf (errmsg, "procfs: %s line %d, %s", func, line, pi->pathname); + xsnprintf (errmsg, sizeof (errmsg), "procfs: %s line %d, %s", + func, line, pi->pathname); perror_with_name (errmsg); } @@ -644,8 +637,7 @@ static int proc_get_status (procinfo *pi) { /* Status file descriptor is opened "lazily". */ - if (pi->status_fd == 0 && - open_procinfo_files (pi, FD_STATUS) == 0) + if (pi->status_fd == 0 && open_procinfo_files (pi, FD_STATUS) == 0) { pi->status_valid = 0; return 0; @@ -886,8 +878,7 @@ proc_stop_process (procinfo *pi) /* We might conceivably apply this operation to an LWP, and the LWP's ctl file descriptor might not be open. */ - if (pi->ctl_fd == 0 && - open_procinfo_files (pi, FD_CTL) == 0) + if (pi->ctl_fd == 0 && open_procinfo_files (pi, FD_CTL) == 0) return 0; else { @@ -952,11 +943,8 @@ proc_run_process (procinfo *pi, int step, int signo) /* We will probably have to apply this operation to individual threads, so make sure the control file descriptor is open. */ - if (pi->ctl_fd == 0 && - open_procinfo_files (pi, FD_CTL) == 0) - { - return 0; - } + if (pi->ctl_fd == 0 && open_procinfo_files (pi, FD_CTL) == 0) + return 0; runflags = PRCFAULT; /* Always clear current fault. */ if (step) @@ -1059,20 +1047,16 @@ proc_set_traced_sysentry (procinfo *pi, sysset_t *sysset) if (pi->tid != 0) pi = find_procinfo_or_die (pi->pid, 0); - struct gdb_proc_ctl_pcsentry { + struct { procfs_ctl_t cmd; /* Use char array to avoid alignment issues. */ char sysset[sizeof (sysset_t)]; - } *argp; - int argp_size = sizeof (struct gdb_proc_ctl_pcsentry); - - argp = (struct gdb_proc_ctl_pcsentry *) xmalloc (argp_size); + } arg; - argp->cmd = PCSENTRY; - memcpy (&argp->sysset, sysset, sizeof (sysset_t)); + arg.cmd = PCSENTRY; + memcpy (&arg.sysset, sysset, sizeof (sysset_t)); - win = (write (pi->ctl_fd, (char *) argp, argp_size) == argp_size); - xfree (argp); + win = (write (pi->ctl_fd, (char *) &arg, sizeof (arg)) == sizeof (arg)); /* The above operation renders the procinfo's cached pstatus obsolete. */ @@ -1101,16 +1085,12 @@ proc_set_traced_sysexit (procinfo *pi, sysset_t *sysset) procfs_ctl_t cmd; /* Use char array to avoid alignment issues. */ char sysset[sizeof (sysset_t)]; - } *argp; - int argp_size = sizeof (struct gdb_proc_ctl_pcsexit); - - argp = (struct gdb_proc_ctl_pcsexit *) xmalloc (argp_size); + } arg; - argp->cmd = PCSEXIT; - memcpy (&argp->sysset, sysset, sizeof (sysset_t)); + arg.cmd = PCSEXIT; + memcpy (&arg.sysset, sysset, sizeof (sysset_t)); - win = (write (pi->ctl_fd, (char *) argp, argp_size) == argp_size); - xfree (argp); + win = (write (pi->ctl_fd, (char *) &arg, sizeof (arg)) == sizeof (arg)); /* The above operation renders the procinfo's cached pstatus obsolete. */ @@ -1445,9 +1425,7 @@ proc_set_gregs (procinfo *pi) return 0; /* proc_get_regs has already warned. */ if (pi->ctl_fd == 0 && open_procinfo_files (pi, FD_CTL) == 0) - { - return 0; - } + return 0; else { struct { @@ -1481,9 +1459,7 @@ proc_set_fpregs (procinfo *pi) return 0; /* proc_get_fpregs has already warned. */ if (pi->ctl_fd == 0 && open_procinfo_files (pi, FD_CTL) == 0) - { - return 0; - } + return 0; else { struct { @@ -1513,11 +1489,8 @@ proc_kill (procinfo *pi, int signo) /* We might conceivably apply this operation to an LWP, and the LWP's ctl file descriptor might not be open. */ - if (pi->ctl_fd == 0 && - open_procinfo_files (pi, FD_CTL) == 0) - { - return 0; - } + if (pi->ctl_fd == 0 && open_procinfo_files (pi, FD_CTL) == 0) + return 0; else { procfs_ctl_t cmd[2]; @@ -1595,7 +1568,7 @@ proc_set_watchpoint (procinfo *pi, CORE_ADDR addr, int len, int wflags) matching ssh struct (LDT entry). */ static struct ssd * -proc_get_LDT_entry (procinfo *pi, int key) +proc_get_LDT_entry (procinfo *pi, int key) /* ARI: editCase function */ { static struct ssd *ldt_entry = NULL; char pathname[MAX_PROC_NAME_SIZE]; @@ -1606,7 +1579,7 @@ proc_get_LDT_entry (procinfo *pi, int key) ldt_entry = XNEW (struct ssd); /* Open the file descriptor for the LDT table. */ - sprintf (pathname, "/proc/%d/ldt", pi->pid); + xsnprintf (pathname, sizeof (pathname), "/proc/%d/ldt", pi->pid); scoped_fd fd (open_with_retry (pathname, O_RDONLY)); if (fd.get () < 0) { @@ -1618,10 +1591,10 @@ proc_get_LDT_entry (procinfo *pi, int key) while (read (fd.get (), ldt_entry, sizeof (struct ssd)) == sizeof (struct ssd)) { - if (ldt_entry->sel == 0 && - ldt_entry->bo == 0 && - ldt_entry->acc1 == 0 && - ldt_entry->acc2 == 0) + if (ldt_entry->sel == 0 + && ldt_entry->bo == 0 + && ldt_entry->acc1 == 0 + && ldt_entry->acc2 == 0) break; /* end of table */ /* If key matches, return this entry. */ if (ldt_entry->sel == key) @@ -1634,21 +1607,23 @@ proc_get_LDT_entry (procinfo *pi, int key) /* Returns the pointer to the LDT entry of PTID. */ struct ssd * -procfs_find_LDT_entry (ptid_t ptid) +procfs_find_LDT_entry (ptid_t ptid) /* ARI: editCase function */ { gdb_gregset_t *gregs; int key; procinfo *pi; /* Find procinfo for the lwp. */ - if ((pi = find_procinfo (ptid.pid (), ptid.lwp ())) == NULL) + pi = find_procinfo (ptid.pid (), ptid.lwp ()); + if (pi == NULL) { warning (_("procfs_find_LDT_entry: could not find procinfo for %d:%ld."), ptid.pid (), ptid.lwp ()); return NULL; } /* get its general registers. */ - if ((gregs = proc_get_gregs (pi)) == NULL) + gregs = proc_get_gregs (pi); + if (gregs == NULL) { warning (_("procfs_find_LDT_entry: could not read gregs for %d:%ld."), ptid.pid (), ptid.lwp ()); @@ -1763,7 +1738,8 @@ proc_update_threads (procinfo *pi) if (direntry->d_name[0] != '.') /* skip '.' and '..' */ { lwpid = atoi (&direntry->d_name[0]); - if ((thread = create_procinfo (pi->pid, lwpid)) == NULL) + thread = create_procinfo (pi->pid, lwpid); + if (thread == NULL) proc_error (pi, "update_threads, create_procinfo", __LINE__); } pi->threads_valid = 1; @@ -1802,7 +1778,8 @@ proc_iterate_over_threads (procinfo *pi, for (thread = pi->thread_list; thread != NULL; thread = next) { next = thread->next; /* In case thread is destroyed. */ - if ((retval = (*func) (pi, thread, ptr)) != 0) + retval = (*func) (pi, thread, ptr); + if (retval != 0) break; } @@ -1851,7 +1828,7 @@ procfs_debug_inferior (procinfo *pi) /* Register to trace the 'exit' system call (on entry). */ - traced_syscall_entries = sysset_t_alloc (pi); + traced_syscall_entries = XNEW (sysset_t); premptyset (traced_syscall_entries); praddset (traced_syscall_entries, SYS_exit); praddset (traced_syscall_entries, SYS_lwp_exit); @@ -1867,7 +1844,7 @@ procfs_debug_inferior (procinfo *pi) names. On the SGI, for example, there is no SYS_exec, but there *is* a SYS_execv. So, we try to account for that. */ - traced_syscall_exits = sysset_t_alloc (pi); + traced_syscall_exits = XNEW (sysset_t); premptyset (traced_syscall_exits); #ifdef SYS_exec praddset (traced_syscall_exits, SYS_exec); @@ -1946,14 +1923,16 @@ do_attach (ptid_t ptid) int fail; int lwpid; - if ((pi = create_procinfo (ptid.pid (), 0)) == NULL) + pi = create_procinfo (ptid.pid (), 0); + if (pi == NULL) perror (_("procfs: out of memory in 'attach'")); if (!open_procinfo_files (pi, FD_CTL)) { fprintf_filtered (gdb_stderr, "procfs:%d -- ", __LINE__); - sprintf (errmsg, "do_attach: couldn't open /proc file for process %d", - ptid.pid ()); + xsnprintf (errmsg, sizeof (errmsg), + "do_attach: couldn't open /proc file for process %d", + ptid.pid ()); dead_procinfo (pi, errmsg, NOKILL); } @@ -1989,7 +1968,8 @@ do_attach (ptid_t ptid) if (!proc_get_held_signals (pi, &pi->saved_sighold)) dead_procinfo (pi, "do_attach: couldn't save held signals.", NOKILL); - if ((fail = procfs_debug_inferior (pi)) != 0) + fail = procfs_debug_inferior (pi); + if (fail != 0) dead_procinfo (pi, "do_attach: failed in procfs_debug_inferior", NOKILL); inf = current_inferior (); @@ -2232,8 +2212,8 @@ wait_again: pi->status_valid = 0; /* re-read again, IMMEDIATELY... */ #endif /* If child is not stopped, wait for it to stop. */ - if (!(proc_flags (pi) & (PR_STOPPED | PR_ISTOP)) && - !proc_wait_for_stop (pi)) + if (!(proc_flags (pi) & (PR_STOPPED | PR_ISTOP)) + && !proc_wait_for_stop (pi)) { /* wait_for_stop failed: has the child terminated? */ if (errno == ENOENT) @@ -2357,8 +2337,10 @@ wait_again: long i, nsysargs, *sysargs; - if ((nsysargs = proc_nsysarg (pi)) > 0 && - (sysargs = proc_sysargs (pi)) != NULL) + nsysargs = proc_nsysarg (pi); + sysargs = proc_sysargs (pi); + + if (nsysargs > 0 && sysargs != NULL) { printf_filtered (_("%ld syscall arguments:\n"), nsysargs); @@ -2441,8 +2423,10 @@ wait_again: long i, nsysargs, *sysargs; - if ((nsysargs = proc_nsysarg (pi)) > 0 && - (sysargs = proc_sysargs (pi)) != NULL) + nsysargs = proc_nsysarg (pi); + sysargs = proc_sysargs (pi); + + if (nsysargs > 0 && sysargs != NULL) { printf_filtered (_("%ld syscall arguments:\n"), nsysargs); @@ -2530,9 +2514,9 @@ wait_again: } /* Got this far without error: If retval isn't in the threads database, add it. */ - if (retval.pid () > 0 && - retval != inferior_ptid && - !in_thread_list (retval)) + if (retval.pid () > 0 + && retval != inferior_ptid + && !in_thread_list (retval)) { /* We have a new thread. We need to add it both to GDB's list and to our own. If we don't create a @@ -2598,8 +2582,7 @@ procfs_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf, /* Find procinfo for main process. */ pi = find_procinfo_or_die (inferior_ptid.pid (), 0); - if (pi->as_fd == 0 && - open_procinfo_files (pi, FD_AS) == 0) + if (pi->as_fd == 0 && open_procinfo_files (pi, FD_AS) == 0) { proc_warn (pi, "xfer_memory, open_proc_files", __LINE__); return TARGET_XFER_E_IO; @@ -2647,15 +2630,13 @@ invalidate_cache (procinfo *parent, procinfo *pi, void *ptr) #if 0 if (pi->gregs_dirty) - if (parent == NULL || - proc_get_current_thread (parent) != pi->tid) + if (parent == NULL || proc_get_current_thread (parent) != pi->tid) if (!proc_set_gregs (pi)) /* flush gregs cache */ proc_warn (pi, "target_resume, set_gregs", __LINE__); if (gdbarch_fp0_regnum (target_gdbarch ()) >= 0) if (pi->fpregs_dirty) - if (parent == NULL || - proc_get_current_thread (parent) != pi->tid) + if (parent == NULL || proc_get_current_thread (parent) != pi->tid) if (!proc_set_fpregs (pi)) /* flush fpregs cache */ proc_warn (pi, "target_resume, set_fpregs", __LINE__); @@ -2740,8 +2721,7 @@ procfs_target::resume (ptid_t ptid, int step, enum gdb_signal signo) errno = 0; /* Convert signal to host numbering. */ - if (signo == 0 || - (signo == GDB_SIGNAL_STOP && pi->ignore_next_sigstop)) + if (signo == 0 || (signo == GDB_SIGNAL_STOP && pi->ignore_next_sigstop)) native_signo = 0; else native_signo = gdb_signal_to_host (signo); @@ -2906,7 +2886,8 @@ procfs_init_inferior (struct target_ops *ops, int pid) if (!target_is_pushed (ops)) push_target (ops); - if ((pi = create_procinfo (pid, 0)) == NULL) + pi = create_procinfo (pid, 0); + if (pi == NULL) perror (_("procfs: out of memory in 'init_inferior'")); if (!open_procinfo_files (pi, FD_CTL)) @@ -2925,8 +2906,7 @@ procfs_init_inferior (struct target_ops *ops, int pid) */ /* If not stopped yet, wait for it to stop. */ - if (!(proc_flags (pi) & PR_STOPPED) && - !(proc_wait_for_stop (pi))) + if (!(proc_flags (pi) & PR_STOPPED) && !(proc_wait_for_stop (pi))) dead_procinfo (pi, "init_inferior: wait_for_stop failed", KILL); /* Save some of the /proc state to be restored if we detach. */ @@ -2943,7 +2923,8 @@ procfs_init_inferior (struct target_ops *ops, int pid) if (!proc_get_traced_sysexit (pi, pi->saved_exitset)) proc_error (pi, "init_inferior, get_traced_sysexit", __LINE__); - if ((fail = procfs_debug_inferior (pi)) != 0) + fail = procfs_debug_inferior (pi); + if (fail != 0) proc_error (pi, "init_inferior (procfs_debug_inferior)", fail); /* FIXME: logically, we should really be turning OFF run-on-last-close, @@ -2988,7 +2969,8 @@ procfs_set_exec_trap (void) procinfo *pi; sysset_t *exitset; - if ((pi = create_procinfo (getpid (), 0)) == NULL) + pi = create_procinfo (getpid (), 0); + if (pi == NULL) perror_with_name (_("procfs: create_procinfo failed in child.")); if (open_procinfo_files (pi, FD_CTL) == 0) @@ -3006,7 +2988,7 @@ procfs_set_exec_trap (void) names. On the SGI, for example, there is no SYS_exec, but there *is* a SYS_execv. So, we try to account for that. */ - exitset = sysset_t_alloc (pi); + exitset = XNEW (sysset_t); premptyset (exitset); #ifdef SYS_exec praddset (exitset, SYS_exec); @@ -3185,7 +3167,8 @@ procfs_target::thread_alive (ptid_t ptid) proc = ptid.pid (); thread = ptid.lwp (); /* If I don't know it, it ain't alive! */ - if ((pi = find_procinfo (proc, thread)) == NULL) + pi = find_procinfo (proc, thread); + if (pi == NULL) return false; /* If I can't get its status, it ain't alive! @@ -3209,9 +3192,9 @@ procfs_target::pid_to_str (ptid_t ptid) static char buf[80]; if (ptid.lwp () == 0) - sprintf (buf, "process %d", ptid.pid ()); + xsnprintf (buf, sizeof (buf), "process %d", ptid.pid ()); else - sprintf (buf, "LWP %ld", ptid.lwp ()); + xsnprintf (buf, sizeof (buf), "LWP %ld", ptid.lwp ()); return buf; } @@ -3226,7 +3209,7 @@ procfs_target::pid_to_exec_file (int pid) char name[PATH_MAX]; /* Solaris 11 introduced /proc//execname. */ - xsnprintf (name, PATH_MAX, "/proc/%d/execname", pid); + xsnprintf (name, sizeof (name), "/proc/%d/execname", pid); scoped_fd fd (gdb_open_cloexec (name, O_RDONLY, 0)); if (fd.get () < 0 || read (fd.get (), buf, PATH_MAX - 1) < 0) { @@ -3234,7 +3217,7 @@ procfs_target::pid_to_exec_file (int pid) Solaris 10. */ ssize_t len; - xsnprintf (name, PATH_MAX, "/proc/%d/path/a.out", pid); + xsnprintf (name, sizeof (name), "/proc/%d/path/a.out", pid); len = readlink (name, buf, PATH_MAX - 1); if (len <= 0) strcpy (buf, name); @@ -3335,13 +3318,9 @@ procfs_target::stopped_by_watchpoint () pi = find_procinfo_or_die (inferior_ptid.pid (), 0); if (proc_flags (pi) & (PR_STOPPED | PR_ISTOP)) - { - if (proc_why (pi) == PR_FAULTED) - { - if (proc_what (pi) == FLTWATCH) - return true; - } - } + if (proc_why (pi) == PR_FAULTED) + if (proc_what (pi) == FLTWATCH) + return true; return false; } @@ -3367,20 +3346,16 @@ procfs_target::insert_watchpoint (CORE_ADDR addr, int len, { if (!target_have_steppable_watchpoint && !gdbarch_have_nonsteppable_watchpoint (target_gdbarch ())) - { - /* When a hardware watchpoint fires off the PC will be left at - the instruction following the one which caused the - watchpoint. It will *NOT* be necessary for GDB to step over - the watchpoint. */ - return procfs_set_watchpoint (inferior_ptid, addr, len, type, 1); - } + /* When a hardware watchpoint fires off the PC will be left at + the instruction following the one which caused the + watchpoint. It will *NOT* be necessary for GDB to step over + the watchpoint. */ + return procfs_set_watchpoint (inferior_ptid, addr, len, type, 1); else - { - /* When a hardware watchpoint fires off the PC will be left at - the instruction which caused the watchpoint. It will be - necessary for GDB to step over the watchpoint. */ - return procfs_set_watchpoint (inferior_ptid, addr, len, type, 0); - } + /* When a hardware watchpoint fires off the PC will be left at + the instruction which caused the watchpoint. It will be + necessary for GDB to step over the watchpoint. */ + return procfs_set_watchpoint (inferior_ptid, addr, len, type, 0); } int @@ -3433,7 +3408,7 @@ iterate_over_mappings (procinfo *pi, find_memory_region_ftype child_func, /* Get the number of mappings, allocate space, and read the mappings into prmaps. */ /* Open map fd. */ - sprintf (pathname, "/proc/%d/map", pi->pid); + xsnprintf (pathname, sizeof (pathname), "/proc/%d/map", pi->pid); scoped_fd map_fd (open (pathname, O_RDONLY)); if (map_fd.get () < 0) @@ -3451,8 +3426,11 @@ iterate_over_mappings (procinfo *pi, find_memory_region_ftype child_func, proc_error (pi, "iterate_over_mappings (read)", __LINE__); for (prmap = prmaps; nmap > 0; prmap++, nmap--) - if ((funcstat = (*func) (prmap, child_func, data)) != 0) - return funcstat; + { + funcstat = (*func) (prmap, child_func, data); + if (funcstat != 0) + return funcstat; + } return 0; } @@ -3658,9 +3636,7 @@ procfs_target::info_proc (const char *args, enum info_proc_what what) } if (mappings) - { - info_proc_mappings (process, 0); - } + info_proc_mappings (process, 0); return true; } @@ -3891,8 +3867,9 @@ procfs_target::make_corefile_notes (bfd *obfd, int *note_size) psargs[sizeof (psargs) - 1] = 0; inf_args = get_inferior_args (); - if (inf_args && *inf_args && - strlen (inf_args) < ((int) sizeof (psargs) - (int) strlen (psargs))) + if (inf_args && *inf_args + && (strlen (inf_args) + < ((int) sizeof (psargs) - (int) strlen (psargs)))) { strncat (psargs, " ", sizeof (psargs) - strlen (psargs)); diff --git a/gdb/sol-thread.c b/gdb/sol-thread.c index a5980f199ec..5cdc9a8c1e5 100644 --- a/gdb/sol-thread.c +++ b/gdb/sol-thread.c @@ -705,9 +705,11 @@ sol_thread_target::thread_alive (ptid_t ptid) int pid; pid = ptid.tid (); - if ((val = p_td_ta_map_id2thr (main_ta, pid, &th)) != TD_OK) + val = p_td_ta_map_id2thr (main_ta, pid, &th); + if (val != TD_OK) return false; /* Thread not found. */ - if ((val = p_td_thr_validate (&th)) != TD_OK) + val = p_td_thr_validate (&th); + if (val != TD_OK) return false; /* Thread not valid. */ return true; /* Known thread. */ } @@ -943,7 +945,6 @@ ps_lsetfpregs (struct ps_prochandle *ph, lwpid_t lwpid, return PS_OK; } -#ifdef PR_MODEL_LP64 /* Identify process as 32-bit or 64-bit. At the moment we're using BFD to do this. There might be a more Solaris-specific (e.g. procfs) method, but this ought to work. */ @@ -960,7 +961,6 @@ ps_pdmodel (struct ps_prochandle *ph, int *data_model) return PS_OK; } -#endif /* PR_MODEL_LP64 */ #if (defined(__i386__) || defined(__x86_64__)) && defined (sun) @@ -970,8 +970,7 @@ ps_pdmodel (struct ps_prochandle *ph, int *data_model) of libthread_db would fail because of ps_lgetLDT being undefined. */ ps_err_e -ps_lgetLDT (struct ps_prochandle *ph, lwpid_t lwpid, - struct ssd *pldt) +ps_lgetLDT (struct ps_prochandle *ph, lwpid_t lwpid, struct ssd *pldt) /* ARI: editCase function */ { /* NOTE: only used on Solaris, therefore OK to refer to procfs.c. */ struct ssd *ret; diff --git a/gdb/sparc-sol2-nat.c b/gdb/sparc-sol2-nat.c index 2c0d561f98d..d03ef71c7de 100644 --- a/gdb/sparc-sol2-nat.c +++ b/gdb/sparc-sol2-nat.c @@ -40,16 +40,10 @@ PR_MODEL_LP64, we know that GDB is being compiled as a 64-bit program. - GNU/Linux uses the same formats as Solaris for its core files (but - not for ptrace(2)). The GNU/Linux headers don't define - PR_MODEL_NATIVE though. Therefore we rely on the __arch64__ define - provided by GCC to determine the appropriate data model. - Note that a 32-bit GDB won't be able to debug a 64-bit target process using /proc on Solaris. */ -#if (defined (__arch64__) || \ - (defined (PR_MODEL_NATIVE) && (PR_MODEL_NATIVE == PR_MODEL_LP64))) +#if PR_MODEL_NATIVE == PR_MODEL_LP64 #include "sparc64-tdep.h"