From: Craig Small Date: Tue, 22 Feb 2011 09:35:14 +0000 (+1100) Subject: Added SF patches and bug reports X-Git-Tag: v22.14~5 X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=64e6225cb3c033c2de50d163e894dc0210cdb5fb;p=psmisc Added SF patches and bug reports * Applied patch from Werner Fink to avoid stat(2) on NFS mounts * Zeros process group memory - Patch by jgorig SF#3152925 RH#666213 * fuser -m -s flags work - Patch by jgorig SF#31110178 RH#651794 * fuser silent if /proc/swaps not available SF#3072134 * ppc 64 support for peekfd by jgorig SF#3166444 * jiffies now ULL in killall SF#3138538 * pstree can show parents of a process. Patch supplied by Curtis Hawthorne SF#3135157 --- diff --git a/ChangeLog b/ChangeLog index 7eee9e7..b421d68 100644 --- a/ChangeLog +++ b/ChangeLog @@ -4,6 +4,14 @@ Changes in 22.14 * Strip @ symbol from file names read from /proc/net/unix * Above 2 changes close openSuSE bugs #536209, #529520, and #417841 and provided by Werner Fink + * Applied patch from Werner Fink to avoid stat(2) on NFS mounts + * Zeros process group memory - Patch by jgorig SF#3152925 RH#666213 + * fuser -m -s flags work - Patch by jgorig SF#31110178 RH#651794 + * fuser silent if /proc/swaps not available SF#3072134 + * ppc 64 support for peekfd by jgorig SF#3166444 + * jiffies now ULL in killall SF#3138538 + * pstree can show parents of a process. Patch supplied by Curtis + Hawthorne SF#3135157 Changes in 22.13 ================ diff --git a/doc/killall.1 b/doc/killall.1 index 229905c..ed6c278 100644 --- a/doc/killall.1 +++ b/doc/killall.1 @@ -1,4 +1,4 @@ -.TH KILLALL 1 2009-12-18 "Linux" "User Commands" +.TH KILLALL 1 2011-02-22 "Linux" "User Commands" .SH NAME killall \- kill processes by name .SH SYNOPSIS @@ -117,7 +117,7 @@ If processes change their name, \fBkillall\fP may not be able to match them correctly. .SH AUTHORS Werner Almesberger wrote the original version -of psmisc. Since version 20 Craig Small +of psmisc. Since version 20 Craig Small can be blamed. .SH "SEE ALSO" .BR kill "(1), " fuser "(1), " pgrep "(1), " pidof "(1), " pkill "(1), " diff --git a/doc/pstree.1 b/doc/pstree.1 index 0b572ba..b30717a 100644 --- a/doc/pstree.1 +++ b/doc/pstree.1 @@ -1,4 +1,4 @@ -.TH PSTREE 1 2009-12-16 "Linux" "User Commands" +.TH PSTREE 1 2011-02-22 "Linux" "User Commands" .SH NAME pstree \- display a tree of processes .SH SYNOPSIS @@ -10,6 +10,7 @@ pstree \- display a tree of processes .RB [ \-l | \-\-long ] .RB [ \-n | \-\-numeric\-sort ] .RB [ \-p | \-\-show\-pids ] +.RB [ \-s | \-\-show\-parents ] .RB [ \-u | \-\-uid\-changes ] .RB [ \-Z | \-\-security\-context ] .RB [ \-A | \-\-ascii | \-G | \-\-vt100 | \-U | \-\-unicode ] @@ -83,6 +84,8 @@ sort.) .IP \fB\-p\fP Show PIDs. PIDs are shown as decimal numbers in parentheses after each process name. \fB\-p\fP implicitly disables compaction. +.IP \fB\-s\fP +Show parent processes of the specified process. .IP \fB\-u\fP Show uid transitions. Whenever the uid of a process differs from the uid of its parent, the new uid is shown in parentheses after the process name. @@ -101,7 +104,7 @@ pstree is compilied with SELinux support. .fi .SH AUTHORS Werner Almesberger -Craig Small +Craig Small .SH BUGS Some character sets may be incompatible with the VT100 characters. diff --git a/src/fuser.c b/src/fuser.c index 4688dfe..65bd5ae 100644 --- a/src/fuser.c +++ b/src/fuser.c @@ -32,9 +32,11 @@ #include #include #include +#include #include #include #include +#include #include #include #include @@ -45,6 +47,7 @@ #include #include #include +#include #include "fuser.h" #include "signals.h" @@ -95,6 +98,16 @@ static void debug_match_lists(struct names *names_head, struct device_list *dev_head); #endif +#ifdef _LISTS_H +static void clear_mntinfo(void) __attribute__((__destructor__)); +static void init_mntinfo(void) __attribute__((__constructor__)); +static dev_t device(const char *path); +#endif +static char *expandpath(const char *path); + +typedef int (*stat_t)(const char*, struct stat*); +static int timeout(stat_t func, const char *path, struct stat *buf, unsigned int seconds); + static void usage(const char *errormsg) { if (errormsg != NULL) @@ -153,7 +166,7 @@ scan_procs(struct names *names_head, struct inode_list *ino_head, struct device_list *dev_tmp; pid_t pid, my_pid; uid_t uid; - struct stat *cwd_stat, *exe_stat, *root_stat; + int dfd; if ((topproc_dir = opendir("/proc")) == NULL) { fprintf(stderr, _("Cannot open /proc directory: %s\n"), @@ -161,7 +174,17 @@ scan_procs(struct names *names_head, struct inode_list *ino_head, exit(1); } my_pid = getpid(); + dfd = dirfd(topproc_dir); while ((topproc_dent = readdir(topproc_dir)) != NULL) { + dev_t cwd_dev, exe_dev, root_dev; + struct stat *cwd_stat = NULL; + struct stat *exe_stat = NULL; + struct stat *root_stat = NULL; +#ifdef _LISTS_H + char path[256] = "/proc/", *slash; + ssize_t len; +#endif + if (topproc_dent->d_name[0] < '0' || topproc_dent->d_name[0] > '9') /* Not a process */ continue; pid = atoi(topproc_dent->d_name); @@ -170,57 +193,72 @@ scan_procs(struct names *names_head, struct inode_list *ino_head, continue; uid = getpiduid(pid); - root_stat = get_pidstat(pid, "root"); +#ifdef _LISTS_H + strcpy(&path[6], topproc_dent->d_name); + len = strlen(path); + slash = &path[len]; + + *slash = '\0'; + strcat(slash, "/cwd"); + cwd_dev = device(path); + + *slash = '\0'; + strcat(slash, "/exe"); + exe_dev = device(path); + + *slash = '\0'; + strcat(slash, "/root"); + root_dev = device(path); +#else cwd_stat = get_pidstat(pid, "cwd"); exe_stat = get_pidstat(pid, "exe"); + root_stat = get_pidstat(pid, "root"); + cwd_dev = cwd_stat ? cwd_stat->st_dev : 0; + exe_dev = exe_stat ? exe_stat->st_dev : 0; + root_dev = root_stat ? root_stat->st_dev : 0; +#endif + /* Scan the devices */ - for (dev_tmp = dev_head; dev_tmp != NULL; - dev_tmp = dev_tmp->next) { - if (exe_stat != NULL - && exe_stat->st_dev == dev_tmp->device) - add_matched_proc(dev_tmp->name, pid, uid, - ACCESS_EXE); - if (root_stat != NULL - && root_stat->st_dev == dev_tmp->device) - add_matched_proc(dev_tmp->name, pid, uid, - ACCESS_ROOT); - if (cwd_stat != NULL - && cwd_stat->st_dev == dev_tmp->device) - add_matched_proc(dev_tmp->name, pid, uid, - ACCESS_CWD); + for (dev_tmp = dev_head; dev_tmp != NULL; dev_tmp = dev_tmp->next) { + if (exe_dev == dev_tmp->device) + add_matched_proc(dev_tmp->name, pid, uid, ACCESS_EXE); + if (root_dev == dev_tmp->device) + add_matched_proc(dev_tmp->name, pid, uid, ACCESS_ROOT); + if (cwd_dev == dev_tmp->device) + add_matched_proc(dev_tmp->name, pid, uid, ACCESS_CWD); } - for (ino_tmp = ino_head; ino_tmp != NULL; - ino_tmp = ino_tmp->next) { - if (exe_stat != NULL) { - if (exe_stat->st_dev == ino_tmp->device - && exe_stat->st_ino == ino_tmp->inode) { - add_matched_proc(ino_tmp->name, pid, - uid, ACCESS_EXE); - } + for (ino_tmp = ino_head; ino_tmp != NULL; ino_tmp = ino_tmp->next) { + if (exe_dev == ino_tmp->device) { + if (!exe_stat) + exe_stat = get_pidstat(pid, "exe"); + if (exe_stat && exe_stat->st_dev == ino_tmp->device + && exe_stat->st_ino == ino_tmp->inode) + add_matched_proc(ino_tmp->name, pid, uid, ACCESS_EXE); } - if (root_stat != NULL) { - if (root_stat->st_dev == ino_tmp->device - && root_stat->st_ino == ino_tmp->inode) { - add_matched_proc(ino_tmp->name, pid, - uid, ACCESS_ROOT); - } - + if (root_dev == ino_tmp->device) { + if (!root_stat) + root_stat = get_pidstat(pid, "root"); + if (root_stat && root_stat->st_dev == ino_tmp->device + && root_stat->st_ino == ino_tmp->inode) + add_matched_proc(ino_tmp->name, pid, uid, ACCESS_ROOT); } - if (cwd_stat != NULL) { - if (cwd_stat->st_dev == ino_tmp->device - && cwd_stat->st_ino == ino_tmp->inode) { - add_matched_proc(ino_tmp->name, pid, - uid, ACCESS_CWD); - } + if (cwd_dev == ino_tmp->device) { + if (!cwd_stat) + cwd_stat = get_pidstat(pid, "cwd"); + if (cwd_stat && cwd_stat->st_dev == ino_tmp->device + && cwd_stat->st_ino == ino_tmp->inode) + add_matched_proc(ino_tmp->name, pid, uid, ACCESS_CWD); } } if (root_stat) free(root_stat); if (cwd_stat) free(cwd_stat); if (exe_stat) free(exe_stat); +#ifndef __linux__ check_dir(pid, "lib", dev_head, ino_head, uid, ACCESS_MMAP, sockets, netdev); check_dir(pid, "mmap", dev_head, ino_head, uid, ACCESS_MMAP, sockets, netdev); +#endif check_dir(pid, "fd", dev_head, ino_head, uid, ACCESS_FILE, sockets, netdev); check_map(pid, "maps", dev_head, ino_head, uid, ACCESS_MMAP); @@ -393,9 +431,24 @@ add_special_proc(struct names *name_list, const char ptype, const uid_t uid, pptr->command = strdup(command); } -int parse_file(struct names *this_name, struct inode_list **ino_list) +int parse_file(struct names *this_name, struct inode_list **ino_list, const char opts) { - if (stat(this_name->filename, &(this_name->st)) != 0) { + char * new = expandpath(this_name->filename); + if (new) { + if (this_name->filename) + free(this_name->filename); + this_name->filename = strdup(new); + } +#ifdef _LISTS_H + if (opts & OPT_MOUNTS) { + this_name->st.st_dev = device(this_name->filename); + this_name->st.st_ino = 0; + add_inode(ino_list, this_name, this_name->st.st_dev, this_name->st.st_ino); + return 0; + } +#endif + + if (timeout(stat, this_name->filename, &(this_name->st), 5) != 0) { if (errno == ENOENT) fprintf(stderr, _("Specified filename %s does not exist.\n"), this_name->filename); else @@ -1035,11 +1088,12 @@ int main(int argc, char *argv[]) break; default: /* FILE */ this_name->filename = strdup(current_argv); - if (parse_file(this_name, &match_inodes) == 0) { - parse_unixsockets(this_name, &match_inodes, unixsockets); + if (parse_file(this_name, &match_inodes, opts) == 0) { if (opts & OPT_MOUNTS) parse_mounts(this_name, &match_devices, opts); - } + else + parse_unixsockets(this_name, &match_inodes, unixsockets); + } break; } @@ -1264,7 +1318,7 @@ static struct stat *get_pidstat(const pid_t pid, const char *filename) if ((st = (struct stat*)malloc(sizeof(struct stat))) == NULL) return NULL; snprintf(pathname, 256, "/proc/%d/%s", pid, filename); - if (stat(pathname, st) != 0) + if (timeout(stat, pathname, st, 5) != 0) goto out; return st; out: @@ -1284,6 +1338,7 @@ check_dir(const pid_t pid, const char *dirname, struct device_list *dev_head, struct device_list *dev_tmp; struct unixsocket_list *sock_tmp; struct stat st, lst; + dev_t thedev; if ((dirpath = (char*)malloc(MAX_PATHNAME)) == NULL) goto out; @@ -1299,53 +1354,68 @@ check_dir(const pid_t pid, const char *dirname, struct device_list *dev_head, snprintf(filepath, MAX_PATHNAME, "/proc/%d/%s/%s", pid, dirname, direntry->d_name); - if (stat(filepath, &st) != 0) { + +#ifdef _LISTS_H + st.st_ino = 0; + if ((thedev = device(filepath)) < 0) +#else + if (!st.st_ino && timeout(stat, filepath, &st, 5) != 0) +#endif + { fprintf(stderr, _("Cannot stat file %s: %s\n"), filepath, strerror(errno)); } else { - if (st.st_dev == netdev) { + if (thedev == netdev) { for (sock_tmp = sockets; sock_tmp != NULL; sock_tmp = sock_tmp->next) { if (sock_tmp->net_inode == st.st_ino) { st.st_ino = sock_tmp->inode; st.st_dev = sock_tmp->dev; + thedev = sock_tmp->dev; break; } } } for (dev_tmp = dev_head; dev_tmp != NULL; dev_tmp = dev_tmp->next) { - if (st.st_dev == dev_tmp->device) { - if (access == ACCESS_FILE - && (lstat(filepath, &lst) == 0) - && (lst.st_mode & S_IWUSR)) { - add_matched_proc(dev_tmp->name, - pid, uid, - ACCESS_FILEWR | - access); - } else { - add_matched_proc(dev_tmp->name, - pid, uid, - access); - } + if (thedev != dev_tmp->device) + continue; + if (access == ACCESS_FILE + && (lstat(filepath, &lst) == 0) + && (lst.st_mode & S_IWUSR)) { + add_matched_proc(dev_tmp->name, + pid, uid, + ACCESS_FILEWR | + access); + } else { + add_matched_proc(dev_tmp->name, + pid, uid, + access); } } for (ino_tmp = ino_head; ino_tmp != NULL; ino_tmp = ino_tmp->next) { - if (st.st_dev == ino_tmp->device - && st.st_ino == ino_tmp->inode) { - if (access == ACCESS_FILE - && (lstat(filepath, &lst) == 0) - && (lst.st_mode & S_IWUSR)) { - add_matched_proc(ino_tmp->name, - pid, uid, - ACCESS_FILEWR | - access); - } else { - add_matched_proc(ino_tmp->name, - pid, uid, - access); - } + if (thedev != ino_tmp->device) + continue; + if (!st.st_ino && timeout(stat, filepath, &st, 5) != 0) { + fprintf(stderr, + _("Cannot stat file %s: %s\n"), + filepath, strerror(errno)); + continue; + } + if (st.st_ino == ino_tmp->inode) { + if (access == ACCESS_FILE + && (lstat(filepath, &lst) == 0) + && (lst.st_mode & S_IWUSR)) { + add_matched_proc(ino_tmp->name, + pid, uid, + ACCESS_FILEWR | + access); + } else { + add_matched_proc(ino_tmp->name, + pid, uid, + access); + } } } } @@ -1402,7 +1472,7 @@ static uid_t getpiduid(const pid_t pid) if (snprintf(pathname, MAX_PATHNAME, "/proc/%d", pid) < 0) return 0; - if (stat(pathname, &st) != 0) + if (timeout(stat, pathname, &st, 5) != 0) return 0; return st.st_uid; } @@ -1438,7 +1508,7 @@ void fill_unix_cache(struct unixsocket_list **unixsocket_head) path = scanned_path; if (*scanned_path == '@') scanned_path++; - if (stat(scanned_path, &st) < 0) { + if (timeout(stat, scanned_path, &st, 5) < 0) { free(path); continue; } @@ -1583,7 +1653,7 @@ scan_knfsd(struct names *names_head, struct inode_list *ino_head, if ((find_space = strpbrk(line, " \t")) == NULL) continue; *find_space = '\0'; - if (stat(line, &st) != 0) { + if (timeout(stat, line, &st, 5) != 0) { continue; } /* Scan the devices */ @@ -1627,7 +1697,7 @@ scan_mounts(struct names *names_head, struct inode_list *ino_head, if ((find_space = strchr(find_mountp, ' ')) == NULL) continue; *find_space = '\0'; - if (stat(find_mountp, &st) != 0) { + if (timeout(stat, find_mountp, &st, 5) != 0) { continue; } /* Scan the devices */ @@ -1660,7 +1730,7 @@ scan_swaps(struct names *names_head, struct inode_list *ino_head, struct stat st; if ((fp = fopen(PROC_SWAPS, "r")) == NULL) { - fprintf(stderr, "Cannot open %s\n", PROC_SWAPS); + /*fprintf(stderr, "Cannot open %s\n", PROC_SWAPS);*/ return; } /* lines are filename type */ @@ -1674,7 +1744,7 @@ scan_swaps(struct names *names_head, struct inode_list *ino_head, if (*find_space == '\0') continue; } - if (stat(line, &st) != 0) { + if (timeout(stat, line, &st, 5) != 0) { continue; } /* Scan the devices */ @@ -1694,3 +1764,281 @@ scan_swaps(struct names *names_head, struct inode_list *ino_head, } fclose(fp); } + +/* + * Execute stat(2) system call with timeout to avoid deadlock + * on network based file systems. + */ +static sigjmp_buf jenv; + +static void +sigalarm(int sig) +{ + if (sig == SIGALRM) + siglongjmp(jenv, 1); +} + +static int +timeout(stat_t func, const char *path, struct stat *buf, unsigned int seconds) +{ + pid_t pid = 0; + int ret = 0, pipes[4]; + ssize_t len; + + if (pipe(&pipes[0]) < 0) + goto err; + switch ((pid = fork ())) { + case -1: + close(pipes[0]); + close(pipes[1]); + goto err; + case 0: + (void) signal(SIGALRM, SIG_DFL); + close(pipes[0]); + if ((ret = func(path, buf)) == 0) + do len = write(pipes[1], buf, sizeof(struct stat)); + while (len < 0 && errno == EINTR); + close(pipes[1]); + exit(ret); + default: + close(pipes[1]); + if (sigsetjmp(jenv, 1)) { + (void) alarm(0); + (void) signal(SIGALRM, SIG_DFL); + if (waitpid(0, (int*)0, WNOHANG) == 0) + kill(pid, SIGKILL); + errno = ETIMEDOUT; + seconds = 1; + goto err; + } + (void) signal(SIGALRM, sigalarm); + (void) alarm(seconds); + if (read(pipes[0], buf, sizeof(struct stat)) == 0) { + errno = EFAULT; + ret = -1; + } + (void) alarm(0); + (void) signal(SIGALRM, SIG_DFL); + close(pipes[0]); + break; + } + return ret; +err: + return -1; +} + +#ifdef _LISTS_H +/* + * Use /proc/self/mountinfo of modern linux system to determine + * the device numbers of the mount points. Use this to avoid the + * stat(2) system call wherever possible. + */ + +static list_t mntinfo = {&mntinfo, &mntinfo}; + +static void +clear_mntinfo(void) +{ + list_t *ptr, *tmp; + + list_for_each_safe(ptr, tmp, &mntinfo) { + mntinfo_t *mnt = list_entry(ptr, mntinfo_t); + delete(ptr); + free(mnt); + } +} + + +static void +init_mntinfo(void) +{ + char mpoint[PATH_MAX+1]; + int mid, parid, max = 0; + uint maj, min; + list_t sort; + FILE * mnt; + + if (!list_empty(&mntinfo)) + return; + if ((mnt = fopen("/proc/self/mountinfo", "r")) == (FILE*)0) + return; + while (fscanf(mnt, "%i %i %u:%u %*s %s %*[^\n]", &mid, &parid, &maj, &min, &mpoint[0]) == 5) { + const size_t nlen = strlen(mpoint); + mntinfo_t *restrict mnt; + if (posix_memalign((void*)&mnt, sizeof(void*), alignof(mntinfo_t)+(nlen+1)) != 0) { + fprintf(stderr, _("Cannot allocate memory for matched proc: %s\n"), + strerror(errno)); + exit(1); + } + append(mnt, mntinfo); + mnt->mpoint = ((char*)mnt)+alignof(mntinfo_t); + strcpy(mnt->mpoint, mpoint); + mnt->nlen = nlen; + mnt->parid = parid; + mnt->dev = makedev(maj, min); + mnt->id = mid; + if (mid > max) + max = mid; + } + fclose(mnt); + + /* Sort mount points accordingly to the reverse mount order */ + initial(&sort); + for (mid = 1; mid <= max; mid++) { + list_t *ptr, *tmp; + list_for_each_safe(ptr, tmp, &mntinfo) { + mntinfo_t *mnt = list_entry(ptr, mntinfo_t); + if (mid != mnt->id) + continue; + move_head(ptr, &sort); + break; + } + list_for_each_safe(ptr, tmp, &mntinfo) { + mntinfo_t *mnt = list_entry(ptr, mntinfo_t); + if (mid != mnt->parid) + continue; + move_head(ptr, &sort); + } + } + if (!list_empty(&mntinfo)) { + errno = EBADE; + } + join(&sort, &mntinfo); +} + +/* + * Determine device of links below /proc/ + */ +static dev_t +device(const char * path) +{ + char name[PATH_MAX+1]; + const char *use; + ssize_t nlen; + list_t *ptr; + + if ((nlen = readlink(path, name, PATH_MAX)) < 0) { + nlen = strlen(path); + use = &path[0]; + } else { + name[nlen] = '\0'; + use = &name[0]; + } + + if (*use != '/') { /* special file (socket, pipe, inotify) */ + struct stat st; + if (timeout(stat, path, &st, 5) != 0) + return (dev_t)-1; + return st.st_dev; + } + + list_for_each(ptr, &mntinfo) { + mntinfo_t *mnt = list_entry(ptr, mntinfo_t); + if (nlen < mnt->nlen) + continue; + if (mnt->nlen == 1) /* root fs is the last entry */ + return mnt->dev; + if (use[mnt->nlen] != '\0' && use[mnt->nlen] != '/') + continue; + if (strncmp(use, mnt->mpoint, mnt->nlen) == 0) + return mnt->dev; + } + return (dev_t)-1; +} +#endif /* _LISTS_H */ + +/* + * Somehow the realpath(3) glibc function call, nevertheless + * it avoids lstat(2) system calls. + */ +static char real[PATH_MAX+1]; +char* expandpath(const char * path) +{ + char tmpbuf[PATH_MAX+1]; + const char *start, *end; + char *curr, *dest; + int deep = MAXSYMLINKS; + + if (!path || *path == '\0') + return (char*)0; + + curr = &real[0]; + + if (*path != '/') { + if (!getcwd(curr, PATH_MAX)) + return (char*)0; + dest = rawmemchr(curr, '\0'); + } else { + *curr = '/'; + dest = curr + 1; + } + + for (start = end = path; *start; start = end) { + + while (*start == '/') + ++start; + + for (end = start; *end && *end != '/'; ++end) + ; + + if (end - start == 0) + break; + else if (end - start == 1 && start[0] == '.') { + ; + } else if (end - start == 2 && start[0] == '.' && start[1] == '.') { + if (dest > curr + 1) + while ((--dest)[-1] != '/') + ; + } else { + char lnkbuf[PATH_MAX+1]; + size_t len; + ssize_t n; + + if (dest[-1] != '/') + *dest++ = '/'; + + if (dest + (end - start) > curr + PATH_MAX) { + errno = ENAMETOOLONG; + return (char*)0; + } + + dest = mempcpy(dest, start, end - start); + *dest = '\0'; + + if (deep-- < 0) { + errno = ELOOP; + return (char*)0; + } + + errno = 0; + if ((n = readlink(curr, lnkbuf, PATH_MAX)) < 0) { + deep = MAXSYMLINKS; + if (errno == EINVAL) + continue; /* Not a symlink */ + return (char*)0; + } + lnkbuf[n] = '\0'; /* Don't be fooled by readlink(2) */ + + len = strlen(end); + if ((n + len) > PATH_MAX) { + errno = ENAMETOOLONG; + return (char*)0; + } + + memmove(&tmpbuf[n], end, len + 1); + path = end = memcpy(tmpbuf, lnkbuf, n); + + if (lnkbuf[0] == '/') + dest = curr + 1; + else if (dest > curr + 1) + while ((--dest)[-1] != '/'); + + } + } + + if (dest > curr + 1 && dest[-1] == '/') + --dest; + *dest = '\0'; + + return curr; +} diff --git a/src/fuser.h b/src/fuser.h index 209973f..21eb720 100644 --- a/src/fuser.h +++ b/src/fuser.h @@ -86,6 +86,17 @@ struct mount_list { struct mount_list *next; }; +#if defined (__GNUC__) && defined(__OPTIMIZE__) +# include "lists.h" +typedef struct mntinfo_s { + list_t this; + int id, parid; + dev_t dev; + size_t nlen; + char *mpoint; +} mntinfo_t; +#endif + #define NAMESPACE_FILE 0 #define NAMESPACE_TCP 1 #define NAMESPACE_UDP 2 diff --git a/src/killall.c b/src/killall.c index 8b590c2..b3783fe 100644 --- a/src/killall.c +++ b/src/killall.c @@ -142,7 +142,7 @@ uptime() } /* process age from jiffies to seconds via uptime */ -static double process_age(const unsigned jf) +static double process_age(const unsigned long long jf) { double sc_clk_tck = sysconf(_SC_CLK_TCK); assert(sc_clk_tck > 0); @@ -331,7 +331,7 @@ kill_all (int signal, int names, char **namelist, struct passwd *pwent) pgids = NULL; /* silence gcc */ else { - pgids = malloc (pids * sizeof (pid_t)); + pgids = calloc (pids, sizeof (pid_t)); if (!pgids) { perror ("malloc"); @@ -375,7 +375,7 @@ kill_all (int signal, int names, char **namelist, struct passwd *pwent) } if ( younger_than || older_than ) { rewind(file); - unsigned int proc_stt_jf = 0; + unsigned long long proc_stt_jf = 0; okay = fscanf(file, "%*d %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %ull", &proc_stt_jf) == 1; if (!okay) { diff --git a/src/lists.h b/src/lists.h new file mode 100644 index 0000000..d91bbdf --- /dev/null +++ b/src/lists.h @@ -0,0 +1,498 @@ +/* + * lists.h Simple doubly linked list implementation, + * based on and . + * + * Version: 0.1 01-Feb-2011 Fink + * + * Copyright 2011 Werner Fink, 2005 SUSE LINUX Products GmbH, Germany. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * Author: Werner Fink , 2011 + */ + +#ifndef _LISTS_H +#define _LISTS_H + +#include +#include + +typedef enum _boolean {false, true} boolean; +typedef unsigned char uchar; +#ifndef __USE_MISC +typedef unsigned short ushort; +typedef unsigned int uint; +#endif + +#ifndef __OPTIMIZE__ +# warning This will not compile without -O at least +#endif +#if !defined(__STDC_VERSION__) || (__STDC_VERSION__ < 199901L) +# ifndef inline +# define inline __inline__ +# endif +# ifndef restrict +# define restrict __restrict__ +# endif +# ifndef volatile +# define volatile __volatile__ +# endif +# ifndef asm +# define asm __asm__ +# endif +# ifndef extension +# define extension __extension__ +# endif +#endif +#ifndef attribute +# define attribute(attr) __attribute__(attr) +#endif + +/* + * This is lent from the kernel by e.g. using + * + * echo '#include \nint main () { prefetch(); return 0; }' | \ + * gcc -I/usr/src/linux/include -D__KERNEL__ -x c -E -P - | \ + * sed -rn '/void[[:blank:]]+prefetch[[:blank:]]*\(/,/^}/p' + * + * on the appropiate architecture (here on i686 for i586). + */ +extern inline void attribute((used,__gnu_inline__,always_inline,__artificial__)) prefetch(const void *restrict x) +{ +#if defined(__x86_64__) + asm volatile ("prefetcht0 %0" :: "m" (*(unsigned long *)x)) +#elif defined(__ia64__) + asm volatile ("lfetch [%0]" :: "r" (x)) +#elif defined(__powerpc64__) + asm volatile ("dcbt 0,%0" :: "r" (x)) +#elif 1 && defined(__i386__) + asm volatile ("661:\n\t" + ".byte 0x8d,0x74,0x26,0x00\n" + "\n662:\n" + ".section .altinstructions,\"a\"\n" + " .align 4\n" + " .long 661b\n" + " .long 663f\n" + " .byte %c0\n" + " .byte 662b-661b\n" + " .byte 664f-663f\n" + ".previous\n" + ".section .altinstr_replacement,\"ax\"\n" + " 663:\n\t" + " prefetchnta (%1)" + " \n664:\n" + ".previous" + :: "i" ((0*32+25)), "r" (x)) +#else + __builtin_prefetch ((x), 0, 1); +#endif + ; +} + +#if defined(DEBUG) && (DEBUG > 0) +# define __align attribute((packed)) +#else +# define __align attribute((aligned(sizeof(struct list_struct*)))) +#endif +#define __packed attribute((packed)) + +#define alignof(type) ((sizeof(type)+(sizeof(void*)-1)) & ~(sizeof(void*)-1)) +#define strsize(string) ((strlen(string)+1)*sizeof(char)) + +typedef struct list_struct { + struct list_struct * next, * prev; +} __align list_t; + +/* + * Linked list handling + * ==================== + * The structures which will be linked into such lists have to be of the + * same type. The structures may have alway a list identifier of the type + * `list_t' as very first element. With this the macro list_entry() can + * be used to cast the memory address of a list member to the corresponding + * allocated structure. + */ + +/* + * Insert new entry as next member. + */ +static inline void _insert(list_t *restrict new, list_t *restrict here) attribute((always_inline,nonnull(1,2))); +static inline void _insert(list_t *restrict new, list_t *restrict here) +{ + list_t * prev = here; + list_t * next = here->next; + + next->prev = new; + new->next = next; + new->prev = prev; + prev->next = new; +} + +#define insert(new, list) _insert(&((new)->this), (&(list))); +#define append(new, list) _insert(&((new)->this), (&(list))->prev); + +/* + * Set head + */ +static inline void initial(list_t *restrict head) attribute((always_inline,nonnull(1))); +static inline void initial(list_t *restrict head) +{ + head->prev = head->next = head; +} + +/* + * Remove entries, note that the pointer its self remains. + */ +static inline void delete(list_t *restrict entry) attribute((always_inline,nonnull(1))); +static inline void delete(list_t *restrict entry) +{ + list_t * prev = entry->prev; + list_t * next = entry->next; + + next->prev = prev; + prev->next = next; + + initial(entry); +} + +/* + * Replace an entry by a new one. + */ +static inline void replace(list_t *restrict old, list_t *restrict new) attribute((always_inline,nonnull(1,2))); +static inline void replace(list_t *restrict old, list_t *restrict new) +{ + new->next = old->next; + new->next->prev = new; + new->prev = old->prev; + new->prev->next = new; +} + +static inline void join(list_t *restrict list, list_t *restrict head) attribute((always_inline,nonnull(1,2))); +static inline void join(list_t *restrict list, list_t *restrict head) +{ + list_t * first = list->next; + + if (first != list) { + list_t * last = list->prev; + list_t * at = head->next; + + first->prev = head; + head->next = first; + + last->next = at; + at->prev = last; + } +} + +static inline boolean list_empty(const list_t *restrict const head) attribute((always_inline,nonnull(1))); +static inline boolean list_empty(const list_t *restrict const head) +{ + return head->next == head; +} + +static inline void move_head(list_t *restrict entry, list_t *restrict head) attribute((always_inline,nonnull(1,2))); +static inline void move_head(list_t *restrict entry, list_t *restrict head) +{ + list_t * prev = entry->prev; + list_t * next = entry->next; + + next->prev = prev; /* remove entry from old list */ + prev->next = next; + + prev = head; + next = head->next; + + next->prev = entry; /* and add it at head of new list */ + entry->next = next; + entry->prev = prev; + prev->next = entry; +} + +static inline void move_tail(list_t *restrict entry, list_t *restrict head) attribute((always_inline,nonnull(1,2))); +static inline void move_tail(list_t *restrict entry, list_t *restrict head) +{ + list_t * prev = entry->prev; + list_t * next = entry->next; + + next->prev = prev; /* remove entry from old list */ + prev->next = next; + + prev = head->prev; + next = head; + + next->prev = entry; /* and add it at tail of new list */ + entry->next = next; + entry->prev = prev; + prev->next = entry; +} + +/* + * The handle of the list is named `this' + */ +#define list_entry(ptr, type) (__extension__ ({ \ + const typeof( ((type *)0)->this ) *__mptr = (ptr); \ + ((type *)( (char *)(__mptr) - offsetof(type,this) )); })) +#define list_for_each(pos, head) \ + for (pos = (head)->next; prefetch(pos->next), pos != (head); pos = pos->next) +#define np_list_for_each(pos, head) \ + for (pos = (head)->next; pos != (head); pos = pos->next) +#define list_for_each_safe(pos, safe, head) \ + for (pos = (head)->next, safe = pos->next; pos != (head); pos = safe, safe = pos->next) +#define list_for_each_prev(pos, head) \ + for (pos = (head)->prev; prefetch(pos->prev), pos != (head); pos = pos->prev) +#define np_list_for_each_prev(pos, head) \ + for (pos = (head)->prev; pos != (head); pos = pos->prev) + +#endif /* _LISTS_H */ +/* + * lists.h Simple doubly linked list implementation, + * based on and . + * + * Version: 0.1 01-Feb-2011 Fink + * + * Copyright 2011 Werner Fink, 2005 SUSE LINUX Products GmbH, Germany. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * Author: Werner Fink , 2011 + */ + +#ifndef _LISTS_H +#define _LISTS_H + +#include +#include + +typedef enum _boolean {false, true} boolean; +typedef unsigned char uchar; +#ifndef __USE_MISC +typedef unsigned short ushort; +typedef unsigned int uint; +#endif + +#ifndef __OPTIMIZE__ +# warning This will not compile without -O at least +#endif +#if !defined(__STDC_VERSION__) || (__STDC_VERSION__ < 199901L) +# ifndef inline +# define inline __inline__ +# endif +# ifndef restrict +# define restrict __restrict__ +# endif +# ifndef volatile +# define volatile __volatile__ +# endif +# ifndef asm +# define asm __asm__ +# endif +# ifndef extension +# define extension __extension__ +# endif +#endif +#ifndef attribute +# define attribute(attr) __attribute__(attr) +#endif + +/* + * This is lent from the kernel by e.g. using + * + * echo '#include \nint main () { prefetch(); return 0; }' | \ + * gcc -I/usr/src/linux/include -D__KERNEL__ -x c -E -P - | \ + * sed -rn '/void[[:blank:]]+prefetch[[:blank:]]*\(/,/^}/p' + * + * on the appropiate architecture (here on i686 for i586). + */ +extern inline void attribute((used,__gnu_inline__,always_inline,__artificial__)) prefetch(const void *restrict x) +{ +#if defined(__x86_64__) + asm volatile ("prefetcht0 %0" :: "m" (*(unsigned long *)x)) +#elif defined(__ia64__) + asm volatile ("lfetch [%0]" :: "r" (x)) +#elif defined(__powerpc64__) + asm volatile ("dcbt 0,%0" :: "r" (x)) +#elif 1 && defined(__i386__) + asm volatile ("661:\n\t" + ".byte 0x8d,0x74,0x26,0x00\n" + "\n662:\n" + ".section .altinstructions,\"a\"\n" + " .align 4\n" + " .long 661b\n" + " .long 663f\n" + " .byte %c0\n" + " .byte 662b-661b\n" + " .byte 664f-663f\n" + ".previous\n" + ".section .altinstr_replacement,\"ax\"\n" + " 663:\n\t" + " prefetchnta (%1)" + " \n664:\n" + ".previous" + :: "i" ((0*32+25)), "r" (x)) +#else + __builtin_prefetch ((x), 0, 1); +#endif + ; +} + +#if defined(DEBUG) && (DEBUG > 0) +# define __align attribute((packed)) +#else +# define __align attribute((aligned(sizeof(struct list_struct*)))) +#endif +#define __packed attribute((packed)) + +#define alignof(type) ((sizeof(type)+(sizeof(void*)-1)) & ~(sizeof(void*)-1)) +#define strsize(string) ((strlen(string)+1)*sizeof(char)) + +typedef struct list_struct { + struct list_struct * next, * prev; +} __align list_t; + +/* + * Linked list handling + * ==================== + * The structures which will be linked into such lists have to be of the + * same type. The structures may have alway a list identifier of the type + * `list_t' as very first element. With this the macro list_entry() can + * be used to cast the memory address of a list member to the corresponding + * allocated structure. + */ + +/* + * Insert new entry as next member. + */ +static inline void _insert(list_t *restrict new, list_t *restrict here) attribute((always_inline,nonnull(1,2))); +static inline void _insert(list_t *restrict new, list_t *restrict here) +{ + list_t * prev = here; + list_t * next = here->next; + + next->prev = new; + new->next = next; + new->prev = prev; + prev->next = new; +} + +#define insert(new, list) _insert(&((new)->this), (&(list))); +#define append(new, list) _insert(&((new)->this), (&(list))->prev); + +/* + * Set head + */ +static inline void initial(list_t *restrict head) attribute((always_inline,nonnull(1))); +static inline void initial(list_t *restrict head) +{ + head->prev = head->next = head; +} + +/* + * Remove entries, note that the pointer its self remains. + */ +static inline void delete(list_t *restrict entry) attribute((always_inline,nonnull(1))); +static inline void delete(list_t *restrict entry) +{ + list_t * prev = entry->prev; + list_t * next = entry->next; + + next->prev = prev; + prev->next = next; + + initial(entry); +} + +/* + * Replace an entry by a new one. + */ +static inline void replace(list_t *restrict old, list_t *restrict new) attribute((always_inline,nonnull(1,2))); +static inline void replace(list_t *restrict old, list_t *restrict new) +{ + new->next = old->next; + new->next->prev = new; + new->prev = old->prev; + new->prev->next = new; +} + +static inline void join(list_t *restrict list, list_t *restrict head) attribute((always_inline,nonnull(1,2))); +static inline void join(list_t *restrict list, list_t *restrict head) +{ + list_t * first = list->next; + + if (first != list) { + list_t * last = list->prev; + list_t * at = head->next; + + first->prev = head; + head->next = first; + + last->next = at; + at->prev = last; + } +} + +static inline boolean list_empty(const list_t *restrict const head) attribute((always_inline,nonnull(1))); +static inline boolean list_empty(const list_t *restrict const head) +{ + return head->next == head; +} + +static inline void move_head(list_t *restrict entry, list_t *restrict head) attribute((always_inline,nonnull(1,2))); +static inline void move_head(list_t *restrict entry, list_t *restrict head) +{ + list_t * prev = entry->prev; + list_t * next = entry->next; + + next->prev = prev; /* remove entry from old list */ + prev->next = next; + + prev = head; + next = head->next; + + next->prev = entry; /* and add it at head of new list */ + entry->next = next; + entry->prev = prev; + prev->next = entry; +} + +static inline void move_tail(list_t *restrict entry, list_t *restrict head) attribute((always_inline,nonnull(1,2))); +static inline void move_tail(list_t *restrict entry, list_t *restrict head) +{ + list_t * prev = entry->prev; + list_t * next = entry->next; + + next->prev = prev; /* remove entry from old list */ + prev->next = next; + + prev = head->prev; + next = head; + + next->prev = entry; /* and add it at tail of new list */ + entry->next = next; + entry->prev = prev; + prev->next = entry; +} + +/* + * The handle of the list is named `this' + */ +#define list_entry(ptr, type) (__extension__ ({ \ + const typeof( ((type *)0)->this ) *__mptr = (ptr); \ + ((type *)( (char *)(__mptr) - offsetof(type,this) )); })) +#define list_for_each(pos, head) \ + for (pos = (head)->next; prefetch(pos->next), pos != (head); pos = pos->next) +#define np_list_for_each(pos, head) \ + for (pos = (head)->next; pos != (head); pos = pos->next) +#define list_for_each_safe(pos, safe, head) \ + for (pos = (head)->next, safe = pos->next; pos != (head); pos = safe, safe = pos->next) +#define list_for_each_prev(pos, head) \ + for (pos = (head)->prev; prefetch(pos->prev), pos != (head); pos = pos->prev) +#define np_list_for_each_prev(pos, head) \ + for (pos = (head)->prev; pos != (head); pos = pos->prev) + +#endif /* _LISTS_H */ diff --git a/src/peekfd.c b/src/peekfd.c index 6d759b9..c4a3474 100644 --- a/src/peekfd.c +++ b/src/peekfd.c @@ -55,6 +55,9 @@ #define REG_PARAM1 orig_gpr3 #define REG_PARAM2 gpr[4] #define REG_PARAM3 gpr[5] +#ifndef PT_ORIG_R3 + #define PT_ORIG_R3 34 +#endif #elif defined(ARM) #ifndef __ARM_EABI__ #error arm oabi not supported @@ -73,9 +76,6 @@ #define REG_PARAM1 regs[4] #define REG_PARAM2 regs[5] #define REG_PARAM3 regs[6] -#ifndef PT_ORIG_R3 - #define PT_ORIG_R3 34 -#endif #endif #define MAX_ATTACHED_PIDS 1024 @@ -222,11 +222,11 @@ int main(int argc, char **argv) if (WIFSTOPPED(status)) { #ifdef PPC struct pt_regs regs; - regs.gpr[0] = ptrace(PTRACE_PEEKUSER, pid, 4 * PT_R0, 0); - regs.gpr[3] = ptrace(PTRACE_PEEKUSER, pid, 4 * PT_R3, 0); - regs.gpr[4] = ptrace(PTRACE_PEEKUSER, pid, 4 * PT_R4, 0); - regs.gpr[5] = ptrace(PTRACE_PEEKUSER, pid, 4 * PT_R5, 0); - regs.orig_gpr3 = ptrace(PTRACE_PEEKUSER, pid, 4 * PT_ORIG_R3, 0); + regs.gpr[0] = ptrace(PTRACE_PEEKUSER, pid, __WORDSIZE/8 * PT_R0, 0); + regs.gpr[3] = ptrace(PTRACE_PEEKUSER, pid, __WORDSIZE/8 * PT_R3, 0); + regs.gpr[4] = ptrace(PTRACE_PEEKUSER, pid, __WORDSIZE/8 * PT_R4, 0); + regs.gpr[5] = ptrace(PTRACE_PEEKUSER, pid, __WORDSIZE/8 * PT_R5, 0); + regs.orig_gpr3 = ptrace(PTRACE_PEEKUSER, pid, __WORDSIZE/8 * PT_ORIG_R3, 0); #elif defined(ARM) struct pt_regs regs; ptrace(PTRACE_GETREGS, pid, 0, ®s); @@ -271,7 +271,11 @@ int main(int argc, char **argv) for (i = 0; i < regs.REG_PARAM3; i++) { #ifdef _BIG_ENDIAN +#if __WORDSIZE == 64 + unsigned int a = bswap_64(ptrace(PTRACE_PEEKTEXT, pid, regs.REG_PARAM2 + i, 0)); +#else unsigned int a = bswap_32(ptrace(PTRACE_PEEKTEXT, pid, regs.REG_PARAM2 + i, 0)); +#endif #else unsigned int a = ptrace(PTRACE_PEEKTEXT, pid, regs.REG_PARAM2 + i, 0); #endif diff --git a/src/pstree.c b/src/pstree.c index 17a018f..39f345b 100644 --- a/src/pstree.c +++ b/src/pstree.c @@ -122,8 +122,8 @@ static int capacity = 0; static int *width = NULL; static int *more = NULL; -static int print_args = 0, compact = 1, user_change = 0, pids = 0, by_pid = - 0, trunc = 1, wait_end = 0; +static int print_args = 0, compact = 1, user_change = 0, pids = 0, + show_parents = 0, by_pid = 0, trunc = 1, wait_end = 0; #ifdef WITH_SELINUX static int show_scontext = 0; #endif /*WITH_SELINUX */ @@ -581,6 +581,21 @@ static void dump_by_user(PROC * current, uid_t uid) dump_by_user(walk->child, uid); } +static void trim_tree_by_parent(PROC * current) +{ + if (!current) + return; + + PROC * parent = current->parent; + + if (!parent) + return; + + parent->children = NULL; + add_child(parent, current); + trim_tree_by_parent(parent); +} + /* * read_proc now uses a similar method as procps for finding the process @@ -786,6 +801,7 @@ static void usage(void) " -l, --long don't truncate long lines\n" " -n, --numeric-sort sort output by PID\n" " -p, --show-pids show PIDs; implies -c\n" + " -s, --show-parents show parents of the selected process\n" " -u, --uid-changes show uid transitions\n" " -U, --unicode use UTF-8 (Unicode) line drawing characters\n" " -V, --version display version information\n")); @@ -829,9 +845,10 @@ int main(int argc, char **argv) {"vt100", 0, NULL, 'G'}, {"highlight-all", 0, NULL, 'h'}, {"highlight-pid", 1, NULL, 'H'}, + {"long", 0, NULL, 'l'}, {"numeric-sort", 0, NULL, 'n'}, {"show-pids", 0, NULL, 'p'}, - {"long", 0, NULL, 'l'}, + {"show-parents", 0, NULL, 's'}, {"uid-changes", 0, NULL, 'u'}, {"unicode", 0, NULL, 'U'}, {"version", 0, NULL, 'V'}, @@ -884,11 +901,11 @@ int main(int argc, char **argv) #ifdef WITH_SELINUX while ((c = - getopt_long(argc, argv, "aAcGhH:npluUVZ", options, + getopt_long(argc, argv, "aAcGhH:nplsuUVZ", options, NULL)) != -1) #else /*WITH_SELINUX */ while ((c = - getopt_long(argc, argv, "aAcGhH:npluUV", options, NULL)) != -1) + getopt_long(argc, argv, "aAcGhH:nplsuUV", options, NULL)) != -1) #endif /*WITH_SELINUX */ switch (c) { case 'a': @@ -934,6 +951,9 @@ int main(int argc, char **argv) pids = 1; compact = 0; break; + case 's': + show_parents = 1; + break; case 'u': user_change = 1; break; @@ -971,6 +991,13 @@ int main(int argc, char **argv) for (current = find_proc(highlight); current; current = current->parent) current->flags |= PFLAG_HILIGHT; + + if(show_parents && pid != 0) { + trim_tree_by_parent(find_proc(pid)); + + pid = 1; + } + if (!pw) dump_tree(find_proc(pid), 0, 1, 1, 1, 0, 0); else {