From c69d663e7f8414ed45ca31243501856597a7a3a7 Mon Sep 17 00:00:00 2001 From: "Dr. Werner Fink" Date: Tue, 8 Feb 2011 16:55:25 +0000 Subject: [PATCH] . OBS-URL: https://build.opensuse.org/package/show/Base:System/psmisc?expand=0&rev=29 --- psmisc-22.12-nfs4fuser.patch | 903 -------------------------- psmisc-22.12-nfs4fuser.patch.old.bz2 | 3 + psmisc-22.13-nfs4fuser.patch | 931 +++++++++++++++++++++++++++ psmisc-22.13.dif | 12 +- psmisc.changes | 7 + psmisc.spec | 4 +- 6 files changed, 949 insertions(+), 911 deletions(-) delete mode 100644 psmisc-22.12-nfs4fuser.patch create mode 100644 psmisc-22.12-nfs4fuser.patch.old.bz2 create mode 100644 psmisc-22.13-nfs4fuser.patch diff --git a/psmisc-22.12-nfs4fuser.patch b/psmisc-22.12-nfs4fuser.patch deleted file mode 100644 index 6278b3f..0000000 --- a/psmisc-22.12-nfs4fuser.patch +++ /dev/null @@ -1,903 +0,0 @@ ---- doc/fuser.1 -+++ doc/fuser.1 2010-07-13 11:19:41.000000000 +0000 -@@ -88,8 +88,14 @@ List all known signal names. - \fINAME\fR specifies a file on a mounted file system or a block device that - is mounted. All processes accessing files on that file system are listed. - If a directory file is specified, it is automatically changed to --\fINAME\fR/. to use any file system that might be mounted on that --directory. -+\fINAME\fR/. To use any file system that might be mounted on that -+directory. Please note that due the required device ID comparision all -+mounted file systems the -+.BR stat (2) -+system call will applied to every file system even on network file system -+(NFS). If the NFS server does not respond or the network is down the -+.BR stat (2) -+may hang forever. - .TP - \fB\-M\f, \fB\-\-ismountpoint\fR - Request will be fulfilled only if \fINAME\fR specifies a mountpoint. -@@ -174,10 +180,13 @@ The \fB\-k\fR option only works on proce - \fBfuser\fR will print an advice, but take no action beyond that. - .SH BUGS - .PP --fuser \-m /dev/sgX will show (or kill with the \-k flag) all processes, even -+\fBfuser \-m \fI/dev/sgX\fR will show (or kill with the \fB\-k\fR flag) all processes, even - if you don't have that device configured. There may be other devices it - does this for too. - .PP -+\fBfuser \-m \fIname\fR may hang forever if there are NFS file systems mounted -+and one of the NFS servers do not respond or the corresponding network is down. -+.PP - .B fuser - cannot report on any processes that it doesn't have permission to look at - the file descriptor table for. The most common time this problem occurs ---- src/fuser.c -+++ src/fuser.c 2010-07-13 16:28:32.051424747 +0000 -@@ -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" -@@ -67,7 +70,8 @@ static void check_map(const pid_t pid, c - struct device_list *dev_head, - struct inode_list *ino_head, const uid_t uid, - const char access); --static struct stat *get_pidstat(const pid_t pid, const char *filename); -+static struct stat *get_pidstat(const opt_type opts, const pid_t pid, -+ const char *filename, char *real); - static uid_t getpiduid(const pid_t pid); - static int print_matches(struct names *names_head, const opt_type opts, - const int sig_number); -@@ -79,12 +83,12 @@ static void add_device(struct device_lis - struct names *this_name, dev_t device); - void fill_unix_cache(struct unixsocket_list **unixsocket_head); - static dev_t find_net_dev(void); --static void scan_procs(struct names *names_head, struct inode_list *ino_head, -- struct device_list *dev_head, -+static void scan_procs(const opt_type opts, struct names *names_head, -+ struct inode_list *ino_head, struct device_list *dev_head, - struct unixsocket_list *sockets, dev_t netdev); - static void scan_knfsd(struct names *names_head, struct inode_list *ino_head, - struct device_list *dev_head); --static void scan_mounts(struct names *names_head, -+static void scan_mounts(struct names *names_head, struct mount_list *mounts, - struct inode_list *ino_head, - struct device_list *dev_head); - static void scan_swaps(struct names *names_head, struct inode_list *ino_head, -@@ -95,6 +99,13 @@ static void debug_match_lists(struct nam - struct device_list *dev_head); - #endif - -+static struct nfs_points *mnts; -+static void clear_mnt(void); -+static int check4nfs(const char * path, char * real); -+ -+typedef int (*stat_t)(const char*, struct stat*); -+static int nfssafe(stat_t func, const char *path, struct stat *buf); -+ - static void usage(const char *errormsg) - { - if (errormsg != NULL) -@@ -141,8 +152,15 @@ void print_version() - "For more information about these matters, see the files named COPYING.\n")); - } - -+static int islocatedon(const char * path, const char * loc) -+{ -+ if (!path || *path == '\0') -+ return 0; -+ return (strstr(path, loc) == path); -+} -+ - static void --scan_procs(struct names *names_head, struct inode_list *ino_head, -+scan_procs(const opt_type opts, struct names *names_head, struct inode_list *ino_head, - struct device_list *dev_head, struct unixsocket_list *sockets, - dev_t netdev) - { -@@ -153,6 +171,9 @@ scan_procs(struct names *names_head, str - pid_t pid, my_pid; - uid_t uid; - struct stat *cwd_stat, *exe_stat, *root_stat; -+ char root_real[PATH_MAX+1]; -+ char cwd_real[PATH_MAX+1]; -+ char exe_real[PATH_MAX+1]; - - if ((topproc_dir = opendir("/proc")) == NULL) { - fprintf(stderr, _("Cannot open /proc directory: %s\n"), -@@ -169,9 +190,10 @@ scan_procs(struct names *names_head, str - continue; - uid = getpiduid(pid); - -- root_stat = get_pidstat(pid, "root"); -- cwd_stat = get_pidstat(pid, "cwd"); -- exe_stat = get_pidstat(pid, "exe"); -+ root_real[0] = cwd_real[0] = exe_real[0] = '\0'; -+ root_stat = get_pidstat(opts, pid, "root", root_real); -+ cwd_stat = get_pidstat(opts, pid, "cwd", cwd_real); -+ exe_stat = get_pidstat(opts, pid, "exe", exe_real); - /* Scan the devices */ - for (dev_tmp = dev_head; dev_tmp != NULL; - dev_tmp = dev_tmp->next) { -@@ -187,6 +209,17 @@ scan_procs(struct names *names_head, str - && cwd_stat->st_dev == dev_tmp->device) - add_matched_proc(dev_tmp->name, pid, uid, - ACCESS_CWD); -+ if ((dev_tmp->name->name_space & NAMESPACE_NFS) == 0) -+ continue; -+ if (islocatedon(&exe_real[0], dev_tmp->name->filename)) -+ add_matched_proc(dev_tmp->name, pid, uid, -+ ACCESS_EXE); -+ if (islocatedon(&root_real[0], dev_tmp->name->filename)) -+ add_matched_proc(dev_tmp->name, pid, uid, -+ ACCESS_ROOT); -+ if (islocatedon(&cwd_real[0], dev_tmp->name->filename)) -+ add_matched_proc(dev_tmp->name, pid, uid, -+ ACCESS_CWD); - } - for (ino_tmp = ino_head; ino_tmp != NULL; - ino_tmp = ino_tmp->next) { -@@ -212,14 +245,27 @@ scan_procs(struct names *names_head, str - uid, ACCESS_CWD); - } - } -+ if ((ino_tmp->name->name_space & NAMESPACE_NFS) == 0) -+ continue; -+ if (islocatedon(&exe_real[0], ino_tmp->name->filename)) -+ add_matched_proc(ino_tmp->name, pid, uid, -+ ACCESS_EXE); -+ if (islocatedon(&root_real[0], ino_tmp->name->filename)) -+ add_matched_proc(ino_tmp->name, pid, uid, -+ ACCESS_ROOT); -+ if (islocatedon(&cwd_real[0], ino_tmp->name->filename)) -+ 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); -@@ -394,6 +440,23 @@ add_special_proc(struct names *name_list - - int parse_file(struct names *this_name, struct inode_list **ino_list) - { -+ char real[PATH_MAX+1] = ""; -+ -+ real[0] = '\0'; -+ if (check4nfs(this_name->filename, real)) { -+ if (this_name->filename) -+ free(this_name->filename); -+ this_name->filename = strdup(real); -+ this_name->name_space |= NAMESPACE_NFS; -+ add_inode(ino_list, this_name, (dev_t)-1, (ino_t)-1); -+ return 0; -+ } -+ if (real[0] != '\0') { -+ if (this_name->filename) -+ free(this_name->filename); -+ this_name->filename = strdup(real); -+ } -+ - if (stat(this_name->filename, &(this_name->st)) != 0) { - if (errno == ENOENT) - fprintf(stderr, _("Specified filename %s does not exist.\n"), this_name->filename); -@@ -411,12 +474,12 @@ int parse_file(struct names *this_name, - - int - parse_unixsockets(struct names *this_name, struct inode_list **ino_list, -- struct unixsocket_list *sun_head) -+ struct unixsocket_list *sun_head, dev_t net_dev) - { - struct unixsocket_list *sun_tmp; -- dev_t net_dev; - -- net_dev = find_net_dev(); -+ if (this_name->name_space & NAMESPACE_NFS) -+ return 0; - - for (sun_tmp = sun_head; sun_tmp != NULL; sun_tmp = sun_tmp->next) { - if (sun_tmp->dev == this_name->st.st_dev && sun_tmp->inode == this_name->st.st_ino) { -@@ -429,10 +492,14 @@ parse_unixsockets(struct names *this_nam - } - - int --parse_mounts(struct names *this_name, struct device_list **dev_list, -- const char opts) -+parse_mounts(struct names *this_name, struct mount_list *mounts, -+ struct device_list **dev_list) - { - dev_t match_device; -+ struct mount_list *mountptr; -+ -+ if (this_name->name_space & NAMESPACE_NFS) -+ goto skip; - - if (S_ISBLK(this_name->st.st_mode)) - match_device = this_name->st.st_rdev; -@@ -440,6 +507,13 @@ parse_mounts(struct names *this_name, st - match_device = this_name->st.st_dev; - add_device(dev_list, this_name, match_device); - return 0; -+skip: -+ match_device = -1; -+ for (mountptr = mounts ; mountptr != NULL ; mountptr = mountptr->next) { -+ if (strcmp(mountptr->mountpoint, this_name->filename) == 0) -+ add_device(dev_list, this_name, match_device); -+ } -+ return 0; - } - - #ifdef WITH_IPV6 -@@ -758,34 +832,101 @@ find_net6_sockets(struct inode_list **in - } - #endif - -+static inline int isnetfs(const char * type) -+{ -+ static const char* netfs[] = {"nfs", "nfs4", "smbfs", "cifs", "afs", "ncpfs", (char*)0}; -+ int n; -+ for (n = 0; netfs[n]; n++) -+ if (!strcasecmp(netfs[n], type)) -+ return 1; -+ return 0; -+} -+ - static void - read_proc_mounts(struct mount_list **mnt_list) - { -- FILE *fp; -- char line[BUFSIZ]; -- char *find_mountp; -- char *find_space; -- struct mount_list *mnt_tmp; -+ FILE *mntfp; -+ struct mntent *mnt_ptr; -+ struct stat st; -+ const char * mtab; -+ -+ if (stat("/proc/version", &st) < 0) -+ mtab = PROC_MOUNTS; -+ else -+ mtab = "/etc/mtab"; - -- if ((fp = fopen(PROC_MOUNTS, "r")) == NULL) { -- fprintf(stderr, "Cannot open %s\n", PROC_MOUNTS); -+ if ( (mntfp = setmntent(mtab,"r")) == NULL) { -+ fprintf(stderr, _("Cannot open %s: %s\n"), mtab, -+ strerror(errno)); - return; - } -- while (fgets(line, BUFSIZ, fp) != NULL) { -- if ((find_mountp = strchr(line, ' ')) == NULL) -- continue; -- find_mountp++; -- if ((find_space = strchr(find_mountp, ' ')) == NULL) -- continue; -- *find_space = '\0'; -- if ((mnt_tmp = malloc(sizeof(struct mount_list))) == NULL) -+ while ((mnt_ptr = getmntent(mntfp)) != NULL) { -+ struct mount_list *mnt_tmp; -+ if (isnetfs(mnt_ptr->mnt_type)) { -+ /* -+ * Remember all NFS typed partitions, required to make check4nfs() work. -+ */ -+ size_t nlen = strlen(mnt_ptr->mnt_dir); -+ struct nfs_points *restrict p; -+ if (posix_memalign((void*)&p, sizeof(void*), alignof(struct nfs_points)+(nlen+1)) != 0) -+ goto out; -+ p->name = ((char*)p)+alignof(struct nfs_points); -+ p->nlen = nlen; -+ p->shadow = (struct shadow_list*)0; -+ -+ strcpy(p->name, mnt_ptr->mnt_dir); -+ if (mnts) -+ mnts->prev = p; -+ p->next = mnts; -+ p->prev = (struct nfs_points*)0; -+ mnts = p; -+ } -+ if ((mnt_tmp = (struct mount_list*)malloc(sizeof(struct mount_list))) == NULL) - continue; -- if ((mnt_tmp->mountpoint = strdup(find_mountp)) == NULL) -+ if ((mnt_tmp->mountpoint = strdup(mnt_ptr->mnt_dir)) == NULL) - continue; - mnt_tmp->next = *mnt_list; - *mnt_list = mnt_tmp; - } -- fclose(fp); -+ endmntent(mntfp); -+ -+ if (!mnts) -+ return; -+ -+ if ((mntfp = setmntent(mtab, "r")) == NULL) { -+ fprintf(stderr, _("Cannot open %s: %s\n"), mtab, -+ strerror(errno)); -+ return; -+ } -+ -+ while ((mnt_ptr = getmntent(mntfp)) != NULL) { -+ struct nfs_points *p; -+ -+ for (p = mnts; p; p = p->next) { -+ struct shadow_list *s; -+ size_t nlen; -+ -+ if (strcmp(mnt_ptr->mnt_dir, p->name) == 0) -+ continue; -+ if (strncmp(mnt_ptr->mnt_dir, p->name, p->nlen) != 0) -+ continue; -+ -+ nlen = strlen(mnt_ptr->mnt_dir); -+ if (posix_memalign((void*)&s, sizeof(void*), alignof(struct shadow_list)+(nlen+1)) != 0) -+ goto out; -+ s->name = ((char*)s)+alignof(struct shadow_list); -+ s->nlen = nlen; -+ -+ strcpy(s->name, mnt_ptr->mnt_dir); -+ if (p->shadow) -+ p->shadow->prev = s; -+ s->next = p->shadow; -+ s->prev = (struct shadow_list*)0; -+ p->shadow = s; -+ } -+ } -+out: -+ endmntent(mntfp); - } - - static int -@@ -808,6 +949,150 @@ is_mountpoint(struct mount_list **mnt_li - return 0; - } - -+/* -+ * Remove struct nfs_points and its sahdows from memory -+ */ -+static void clear_shadow(struct shadow_list *restrict shadow) -+{ -+ struct shadow_list *s, *n, *l; -+ -+ n = shadow; -+ l = (struct shadow_list*)0; -+ for (s = shadow; n; s = n) { -+ l = s->prev; -+ n = s->next; -+ if (s == shadow) { -+ if (n) n->prev = (struct shadow_list*)0; -+ shadow = n; -+ } else if (l) { -+ if (n) n->prev = l; -+ l->next = n; -+ } -+ free(s); -+ } -+} -+ -+static void clear_mnt(void) -+{ -+ struct nfs_points *p, *n, *l; -+ -+ n = mnts; -+ l = (struct nfs_points*)0; -+ for (p = mnts; n; p = n) { -+ l = p->prev; -+ n = p->next; -+ if (p == mnts) { -+ if (n) n->prev = (struct nfs_points*)0; -+ mnts = n; -+ } else if (l) { -+ if (n) n->prev = l; -+ l->next = n; -+ } -+ if (p->shadow) -+ clear_shadow(p->shadow); -+ free(p); -+ } -+} -+ -+/* -+ * Check if path is a shadow of a NFS partition. -+ */ -+static int shadow(struct shadow_list *restrict this, const char *restrict name, const size_t nlen) -+{ -+ struct shadow_list *s; -+ -+ if (!this) -+ goto out; -+ for (s = this; s; s = s->next) { -+ if (nlen < s->nlen) -+ continue; -+ if (name[s->nlen] != '\0' && name[s->nlen] != '/') -+ continue; -+ if (strncmp(name, s->name, s->nlen) == 0) -+ return 1; -+ } -+out: -+ return 0; -+} -+ -+/* -+ * Check path is located on a NFS partition. -+ */ -+static int check4nfs(const char * path, char * real) -+{ -+ char buf[PATH_MAX+1]; -+ const char *curr; -+ int deep = MAXSYMLINKS; -+ -+ if (!mnts) return 0; -+ -+ curr = path; -+ do { -+ const char *prev; -+ int len; -+ -+ if ((prev = strdupa(curr)) == NULL) -+ return 0; -+ -+ errno = 0; -+ if ((len = readlink(curr, buf, PATH_MAX)) < 0) -+ break; -+ buf[len] = '\0'; /* Don't be fooled by readlink(2) */ -+ -+ if (strncmp(prev, "/proc/", 6) == 0) { -+ curr = &buf[0]; -+ break; /* /proc/ provides the real path! */ -+ } -+ -+ if (len > 10) { -+ char *const ptr = &buf[len - 10]; -+ if (strcmp(ptr, " (deleted)") == 0) { -+ *ptr = '\0'; -+ curr = &buf[0]; -+ break; /* Path is deleted from VFS cache */ -+ } -+ } -+ -+ if (buf[0] != '/') { -+ const char *slash; -+ -+ if ((slash = strrchr(prev, '/'))) { -+ size_t off = slash - prev + 1; -+ -+ if (off + len > PATH_MAX) -+ len = PATH_MAX - off; -+ -+ memmove(&buf[off], &buf[0], len + 1); -+ memcpy(&buf[0], prev, off); -+ } -+ } -+ curr = &buf[0]; -+ -+ if (deep-- <= 0) return 0; -+ -+ } while (1); -+ -+ if (real) strcpy(real, curr); -+ -+ if (errno == EINVAL) { -+ const size_t nlen = strlen(curr); -+ struct nfs_points *p; -+ for (p = mnts; p; p = p->next) { -+ if (nlen < p->nlen) -+ continue; -+ if (curr[p->nlen] != '\0' && curr[p->nlen] != '/') -+ continue; -+ if (!strncmp(curr, p->name, p->nlen)) { -+ if (shadow(p->shadow, curr, nlen)) -+ continue; -+ return 1; -+ } -+ } -+ } -+ -+ return 0; -+} -+ - int main(int argc, char *argv[]) - { - opt_type opts; -@@ -835,6 +1120,7 @@ int main(int argc, char *argv[]) - struct option *optr; - char *nsptr; - int skip_argv; -+ size_t len; - - struct option options[] = { - {"all", 0, NULL, 'a'}, -@@ -931,7 +1217,6 @@ int main(int argc, char *argv[]) - break; - case 'M': - opts |= OPT_ISMOUNTPOINT; -- read_proc_mounts(&mounts); - break; - case 'n': - argc_cnt++; -@@ -979,6 +1264,9 @@ int main(int argc, char *argv[]) - } /* an option */ - /* Not an option, must be a file specification */ - -+ if (!mounts) -+ read_proc_mounts(&mounts); -+ - if ((this_name = malloc(sizeof(struct names))) == NULL) - continue; - this_name->next = NULL; -@@ -1030,11 +1318,24 @@ int main(int argc, char *argv[]) - break; - default: /* FILE */ - this_name->filename = strdup(current_argv); -+ len = strlen(this_name->filename); -+ if (len > 1 && this_name->filename[len-1] == '/') -+ this_name->filename[len-1] = '\0'; -+ if (len > 1 && this_name->filename[0] != '/') { -+ char pwd[MAX_PATHNAME]; -+ if (getcwd(pwd, MAX_PATHNAME-1)) { -+ char *new, *old = this_name->filename; -+ if (asprintf(&new, "%s/%s", (strlen(pwd) > 1 ? pwd : ""), old) > 0) { -+ this_name->filename = new; -+ free(old); -+ } -+ } -+ } - if (parse_file(this_name, &match_inodes) == 0) { -- parse_unixsockets(this_name, &match_inodes, unixsockets); -+ parse_unixsockets(this_name, &match_inodes, unixsockets, netdev); - if (opts & OPT_MOUNTS) -- parse_mounts(this_name, &match_devices, opts); -- } -+ parse_mounts(this_name, mounts, &match_devices); -+ } - break; - } - -@@ -1080,11 +1381,14 @@ int main(int argc, char *argv[]) - #ifdef DEBUG - debug_match_lists(names_head, match_inodes, match_devices); - #endif -- scan_procs(names_head, match_inodes, match_devices, unixsockets, -- netdev); -- scan_knfsd(names_head, match_inodes, match_devices); -- scan_mounts(names_head, match_inodes, match_devices); -- scan_swaps(names_head, match_inodes, match_devices); -+ scan_procs(opts, names_head, match_inodes, match_devices, -+ unixsockets, netdev); -+ if (opts & OPT_VERBOSE) { -+ scan_knfsd(names_head, match_inodes, match_devices); -+ scan_mounts(names_head, mounts, match_inodes, match_devices); -+ scan_swaps(names_head, match_inodes, match_devices); -+ } -+ clear_mnt(); - return print_matches(names_head, opts, sig_number); - } - -@@ -1250,7 +1554,7 @@ print_matches(struct names *names_head, - - } - --static struct stat *get_pidstat(const pid_t pid, const char *filename) -+static struct stat *get_pidstat(const opt_type opts, const pid_t pid, const char *filename, char *real) - { - char pathname[256]; - struct stat *st; -@@ -1258,6 +1562,10 @@ static struct stat *get_pidstat(const pi - if ((st = (struct stat*)malloc(sizeof(struct stat))) == NULL) - return NULL; - snprintf(pathname, 256, "/proc/%d/%s", pid, filename); -+ if (check4nfs(pathname, real)) { -+ if ((opts & OPT_MOUNTS) == 0) -+ return NULL; -+ } - if (stat(pathname, st) != 0) - goto out; - return st; -@@ -1309,6 +1617,16 @@ check_dir(const pid_t pid, const char *d - } - for (dev_tmp = dev_head; dev_tmp != NULL; - dev_tmp = dev_tmp->next) { -+ if (dev_tmp->name->name_space & NAMESPACE_NFS) { -+ char buf[PATH_MAX+1]; -+ ssize_t len; -+ if ((len = readlink(filepath, buf, PATH_MAX)) < 0) -+ continue; -+ buf[len] = '\0'; /* Don't be fooled by readlink(2) */ -+ if (islocatedon(buf, dev_tmp->name->filename)) -+ add_matched_proc(dev_tmp->name, pid,uid, access); -+ continue; -+ } - if (st.st_dev == dev_tmp->device) { - if (access == ACCESS_FILE - && (lstat(filepath, &lst) == 0) -@@ -1326,6 +1644,16 @@ check_dir(const pid_t pid, const char *d - } - for (ino_tmp = ino_head; ino_tmp != NULL; - ino_tmp = ino_tmp->next) { -+ if (ino_tmp->name->name_space & NAMESPACE_NFS) { -+ char buf[PATH_MAX+1]; -+ ssize_t len; -+ if ((len = readlink(filepath, buf, PATH_MAX)) < 0) -+ continue; -+ buf[len] = '\0'; /* Don't be fooled by readlink(2) */ -+ if (islocatedon(buf, ino_tmp->name->filename)) -+ add_matched_proc(ino_tmp->name, pid,uid, access); -+ continue; -+ } - if (st.st_dev == ino_tmp->device - && st.st_ino == ino_tmp->inode) { - if (access == ACCESS_FILE -@@ -1372,18 +1700,41 @@ check_map(const pid_t pid, const char *f - while (fgets(line, BUFSIZ, fp)) { - if (sscanf(line, "%*s %*s %*s %x:%x %lld", - &tmp_maj, &tmp_min, &tmp_inode) == 3) { -+ const char * filepath = strchr(line, '/'); - tmp_device = tmp_maj * 256 + tmp_min; - for (dev_tmp = dev_head; dev_tmp != NULL; -- dev_tmp = dev_tmp->next) -+ dev_tmp = dev_tmp->next) { -+ if (dev_tmp->name->name_space & NAMESPACE_NFS) { -+ char *nl; -+ if (!filepath) -+ continue; -+ if ((nl = strchr(filepath, '\n'))) -+ nl = '\0'; -+ if (islocatedon(filepath, dev_tmp->name->filename)) -+ add_matched_proc(dev_tmp->name, pid,uid, access); -+ continue; -+ } - if (dev_tmp->device == tmp_device) - add_matched_proc(dev_tmp->name, pid, - uid, access); -+ } - for (ino_tmp = ino_head; ino_tmp != NULL; -- ino_tmp = ino_tmp->next) -+ ino_tmp = ino_tmp->next) { -+ if (ino_tmp->name->name_space & NAMESPACE_NFS) { -+ char *nl; -+ if (!filepath) -+ continue; -+ if ((nl = strchr(filepath, '\n'))) -+ nl = '\0'; -+ if (islocatedon(filepath, ino_tmp->name->filename)) -+ add_matched_proc(ino_tmp->name, pid,uid, access); -+ continue; -+ } - if (ino_tmp->device == tmp_device - && ino_tmp->inode == tmp_inode) - add_matched_proc(ino_tmp->name, pid, - uid, access); -+ } - } - } - fclose(fp); -@@ -1571,7 +1922,7 @@ scan_knfsd(struct names *names_head, str - if ((find_space = strpbrk(line, " \t")) == NULL) - continue; - *find_space = '\0'; -- if (stat(line, &st) != 0) { -+ if (nfssafe(stat, line, &st) != 0) { - continue; - } - /* Scan the devices */ -@@ -1580,6 +1931,11 @@ scan_knfsd(struct names *names_head, str - if (st.st_dev == dev_tmp->device) - add_special_proc(dev_tmp->name, PTYPE_KNFSD, 0, - line); -+ if ((dev_tmp->name->name_space & NAMESPACE_NFS) == 0) -+ continue; -+ if (strcmp(line, dev_tmp->name->filename)) -+ continue; -+ add_special_proc(dev_tmp->name, PTYPE_MOUNT, 0, line); - } - for (ino_tmp = ino_head; ino_tmp != NULL; - ino_tmp = ino_tmp->next) { -@@ -1587,53 +1943,55 @@ scan_knfsd(struct names *names_head, str - && st.st_ino == ino_tmp->inode) - add_special_proc(ino_tmp->name, PTYPE_KNFSD, 0, - line); -+ if ((ino_tmp->name->name_space & NAMESPACE_NFS) == 0) -+ continue; -+ if (strcmp(line, ino_tmp->name->filename)) -+ continue; -+ add_special_proc(ino_tmp->name, PTYPE_MOUNT, 0, line); - } - } - fclose(fp); - } - - static void --scan_mounts(struct names *names_head, struct inode_list *ino_head, -- struct device_list *dev_head) -+scan_mounts(struct names *names_head, struct mount_list *mounts, -+ struct inode_list *ino_head, struct device_list *dev_head) - { - struct device_list *dev_tmp; - struct inode_list *ino_tmp; -- FILE *fp; -- char line[BUFSIZ]; -- char *find_mountp; -- char *find_space; -+ struct mount_list *mountptr; - struct stat st; - -- if ((fp = fopen(PROC_MOUNTS, "r")) == NULL) { -- fprintf(stderr, "Cannot open %s\n", PROC_MOUNTS); -- return; -- } -- while (fgets(line, BUFSIZ, fp) != NULL) { -- if ((find_mountp = strchr(line, ' ')) == NULL) -- continue; -- find_mountp++; -- if ((find_space = strchr(find_mountp, ' ')) == NULL) -+ for (mountptr = mounts ; mountptr != NULL ; mountptr = mountptr->next) { -+ if (nfssafe(stat, mountptr->mountpoint, &st) != 0) - continue; -- *find_space = '\0'; -- if (stat(find_mountp, &st) != 0) { -- continue; -- } - /* Scan the devices */ - for (dev_tmp = dev_head; dev_tmp != NULL; - dev_tmp = dev_tmp->next) { - if (st.st_dev == dev_tmp->device) - add_special_proc(dev_tmp->name, PTYPE_MOUNT, 0, -- find_mountp); -+ mountptr->mountpoint); -+ if ((dev_tmp->name->name_space & NAMESPACE_NFS) == 0) -+ continue; -+ if (strcmp(mountptr->mountpoint, dev_tmp->name->filename)) -+ continue; -+ add_special_proc(dev_tmp->name, PTYPE_MOUNT, 0, -+ mountptr->mountpoint); - } - 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) - add_special_proc(ino_tmp->name, PTYPE_MOUNT, 0, -- find_mountp); -+ mountptr->mountpoint); -+ if ((ino_tmp->name->name_space & NAMESPACE_NFS) == 0) -+ continue; -+ if (strcmp(mountptr->mountpoint, ino_tmp->name->filename)) -+ continue; -+ add_special_proc(ino_tmp->name, PTYPE_MOUNT, 0, -+ mountptr->mountpoint); - } - } -- fclose(fp); - } - - static void -@@ -1682,3 +2040,59 @@ scan_swaps(struct names *names_head, str - } - fclose(fp); - } -+ -+static sigjmp_buf jenv; -+static int timeout = 5; -+static void -+sigalarm(int sig) -+{ -+ if (sig == SIGALRM) -+ siglongjmp(jenv, 1); -+} -+static int -+nfssafe(stat_t func, const char *path, struct stat *buf) -+{ -+ pid_t pid = 0; -+ int ret = 0, pipes[4]; -+ -+ 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) -+ write(pipes[1], buf, sizeof(struct stat)); -+ 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; -+ timeout = 1; -+ goto err; -+ } -+ (void) signal(SIGALRM, sigalarm); -+ (void) alarm(timeout); -+ 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; -+} -+ ---- src/fuser.h -+++ src/fuser.h 2010-07-13 12:53:15.000000000 +0000 -@@ -66,6 +66,11 @@ struct inode_list { - struct inode_list *next; - }; - -+struct mountdev_list { -+ char *dir; -+ struct mountdev_list *next; -+}; -+ - struct device_list { - struct names *name; - dev_t device; -@@ -85,9 +90,33 @@ struct mount_list { - struct mount_list *next; - }; - -+struct shadow_list -+{ -+ struct shadow_list *next; -+ struct shadow_list *prev; -+ size_t nlen; -+ char * name; -+}; -+ -+struct nfs_points { -+ struct nfs_points *next, *prev; -+ struct shadow_list *shadow; -+ size_t nlen; -+ char * name; -+}; -+ -+#if !defined(__STDC_VERSION__) || (__STDC_VERSION__ < 199901L) -+# ifndef restrict -+# define restrict __restrict__ -+# endif -+#endif -+#define alignof(type) ((sizeof(type)+(sizeof(void*)-1)) & ~(sizeof(void*)-1)) -+ -+ - #define NAMESPACE_FILE 0 - #define NAMESPACE_TCP 1 - #define NAMESPACE_UDP 2 -+#define NAMESPACE_NFS 4 - - #define MAX_PATHNAME 200 - #define MAX_CMDNAME 16 diff --git a/psmisc-22.12-nfs4fuser.patch.old.bz2 b/psmisc-22.12-nfs4fuser.patch.old.bz2 new file mode 100644 index 0000000..f7a6a47 --- /dev/null +++ b/psmisc-22.12-nfs4fuser.patch.old.bz2 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:37c986a604ebfc72ddeea7dde48a5ddb0c0d8bdd7d81147626157e098243024b +size 6533 diff --git a/psmisc-22.13-nfs4fuser.patch b/psmisc-22.13-nfs4fuser.patch new file mode 100644 index 0000000..8b8db92 --- /dev/null +++ b/psmisc-22.13-nfs4fuser.patch @@ -0,0 +1,931 @@ +--- src/fuser.c ++++ src/fuser.c 2011-02-08 16:25:57.543927495 +0000 +@@ -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 nam + 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) +@@ -152,7 +165,7 @@ scan_procs(struct names *names_head, str + 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"), +@@ -160,7 +173,17 @@ scan_procs(struct names *names_head, str + 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); +@@ -169,57 +192,72 @@ scan_procs(struct names *names_head, str + 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 (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 (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_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); +@@ -392,9 +430,24 @@ add_special_proc(struct names *name_list + 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 +@@ -1030,11 +1083,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; + } + +@@ -1258,7 +1312,7 @@ static struct stat *get_pidstat(const pi + 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: +@@ -1278,6 +1332,7 @@ check_dir(const pid_t pid, const char *d + 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; +@@ -1293,53 +1348,68 @@ check_dir(const pid_t pid, const char *d + + 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); ++ } + } + } + } +@@ -1396,7 +1466,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; + } +@@ -1432,7 +1502,7 @@ void fill_unix_cache(struct unixsocket_l + 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; + } +@@ -1571,7 +1641,7 @@ scan_knfsd(struct names *names_head, str + 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 */ +@@ -1615,7 +1685,7 @@ scan_mounts(struct names *names_head, st + 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 */ +@@ -1662,7 +1732,7 @@ scan_swaps(struct names *names_head, str + if (*find_space == '\0') + continue; + } +- if (stat(line, &st) != 0) { ++ if (timeout(stat, line, &st, 5) != 0) { + continue; + } + /* Scan the devices */ +@@ -1682,3 +1752,279 @@ scan_swaps(struct names *names_head, str + } + 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 != '/') { /* sepcial 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 (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; ++} +--- src/fuser.h ++++ src/fuser.h 2011-02-08 16:25:57.575238622 +0000 +@@ -85,6 +85,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 +--- src/lists.h ++++ src/lists.h 2011-02-07 12:01:52.000000000 +0000 +@@ -0,0 +1,249 @@ ++/* ++ * 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/psmisc-22.13.dif b/psmisc-22.13.dif index 45a175f..427c38e 100644 --- a/psmisc-22.13.dif +++ b/psmisc-22.13.dif @@ -10,18 +10,18 @@ AC_CHECK_MEMBERS([struct pt_regs.orig_gpr3, struct pt_regs.gpr], [],[], [#include ]) --- src/fuser.c -+++ src/fuser.c 2010-07-13 15:01:58.000000000 +0000 -@@ -1120,7 +1120,8 @@ int main(int argc, char *argv[]) ++++ src/fuser.c 2011-02-08 16:08:59.823926228 +0000 +@@ -888,7 +888,8 @@ int main(int argc, char *argv[]) char option_buf[3]; struct option *optr; char *nsptr; - int skip_argv; + int skip_argv; + int seen_file; - size_t len; struct option options[] = { -@@ -1160,6 +1161,7 @@ int main(int argc, char *argv[]) + {"all", 0, NULL, 'a'}, +@@ -927,6 +928,7 @@ int main(int argc, char *argv[]) netdev = find_net_dev(); fill_unix_cache(&unixsockets); @@ -29,7 +29,7 @@ for (argc_cnt = 1; argc_cnt < argc; argc_cnt++) { current_argv = argv[argc_cnt]; if (current_argv[0] == '-') { /* its an option */ -@@ -1291,6 +1293,7 @@ int main(int argc, char *argv[]) +@@ -1056,6 +1058,7 @@ int main(int argc, char *argv[]) } } this_name->matched_procs = NULL; @@ -37,7 +37,7 @@ if (opts & (OPT_MOUNTS|OPT_ISMOUNTPOINT) && this_name->name_space != NAMESPACE_FILE) usage(_ -@@ -1350,7 +1353,7 @@ int main(int argc, char *argv[]) +@@ -1103,7 +1106,7 @@ int main(int argc, char *argv[]) names_tail->next = this_name; names_tail = this_name; } /* for across the argvs */ diff --git a/psmisc.changes b/psmisc.changes index 41f67b4..ddb79f5 100644 --- a/psmisc.changes +++ b/psmisc.changes @@ -1,3 +1,10 @@ +------------------------------------------------------------------- +Tue Feb 8 17:43:57 CET 2011 - werner@suse.de + +- Now use /proc/self/mountinfo to minimize the needs of running + stat(2) system calls. The remaining stat(2) system calls are + wrapped by an timeout function. + ------------------------------------------------------------------- Fri Oct 15 12:36:16 CEST 2010 - werner@suse.de diff --git a/psmisc.spec b/psmisc.spec index 88c4995..1239320 100644 --- a/psmisc.spec +++ b/psmisc.spec @@ -35,7 +35,7 @@ Patch1: %name-22.12-tigetstr.patch Patch2: %name-22.12-pstree_overflow.patch Patch3: %name-22.12-pstree.patch Patch4: %name-22.12-leaks.patch -Patch5: %name-22.12-nfs4fuser.patch +Patch5: %name-22.13-nfs4fuser.patch Patch6: %name-22.12-writeonly.patch Patch7: %name-22.13-peekfd-segv.patch @@ -59,7 +59,7 @@ processes that are using specified files or filesystems. %patch5 -p0 -b .nfs4fuser %patch6 -p0 -b .wrtonly %patch7 -p1 -b .peekfd -%patch0 -p0 +%patch0 -p0 -b .0 %build autoreconf -fi