diff --git a/configure.ac b/configure.ac index 6177975..d54f0ad 100644 --- a/configure.ac +++ b/configure.ac @@ -26,12 +26,12 @@ AC_SUBST([SELINUX_LIB]) dnl Call fork before all stat calls to stop hanging on NFS mounts AC_SUBST([WITH_TIMEOUT_STAT]) -AC_ARG_ENABLE([TIMEOUT_STAT], +AC_ARG_ENABLE([timeout_stat], [AS_HELP_STRING([--enable-timeout-stat], [Use a timeout on stat calls])], [enable_timeout_stat=$enableval], [enable_timeout_stat="no"]) if test "$enable_timeout_stat" = "yes"; then - AC_DEFINE([WITH_timeout_stat], [1], [Use timeout on stat calls]) + AC_DEFINE([WITH_TIMEOUT_STAT], [1], [Use timeout on stat calls]) fi dnl ipv4 only option diff --git a/src/Makefile.am b/src/Makefile.am index 4398631..bbe9170 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -23,7 +23,7 @@ if WANT_PEEKFD_MIPS AM_CFLAGS += -DMIPS endif -fuser_SOURCES = fuser.c comm.h signals.c signals.h i18n.h fuser.h lists.h +fuser_SOURCES = fuser.c comm.h signals.c signals.h timeout.c i18n.h fuser.h lists.h timeout.h fuser_LDADD = @LIBINTL@ diff --git a/src/fuser.c b/src/fuser.c index 476fdf1..374a17d 100644 --- a/src/fuser.c +++ b/src/fuser.c @@ -111,9 +111,8 @@ static dev_t device(const char *path); #endif static char *expandpath(const char *path); -typedef int (*stat_t)(const char*, struct stat*); #ifdef WITH_TIMEOUT_STAT -static int timeout(stat_t func, const char *path, struct stat *buf, unsigned int seconds); +#include "timeout.h" #else #define timeout(func,path,buf,dummy) (func)((path),(buf)) #endif /* WITH_TIMEOUT_STAT */ @@ -1779,70 +1778,6 @@ 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); -} - -#ifdef HAVE_TIMEOUT_STAT -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; -} -#endif /* HAVE_TIMEOUT_STAT */ - #ifdef _LISTS_H /* * Use /proc/self/mountinfo of modern linux system to determine diff --git a/src/timeout.c b/src/timeout.c index e69de29..3b582a3 100644 --- a/src/timeout.c +++ b/src/timeout.c @@ -0,0 +1,215 @@ +/* + * timout.c Advanced timeout handling for file system calls + * to avoid deadlocks on remote file shares. + * + * Version: 0.1 07-Sep-2011 Fink + * + * Copyright 2011 Werner Fink, 2011 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 _GNU_SOURCE +#define _GNU_SOURCE +#endif + +#include "config.h" /* For _FILE_OFFSET_BITS */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include "timeout.h" + +#if !defined(__STDC_VERSION__) || (__STDC_VERSION__ < 199901L) +# ifndef destructor +# define destructor __destructor__ +# endif +# ifndef constructor +# define constructor __constructor__ +# endif +# ifndef packed +# define packed __packed__ +# endif +# ifndef inline +# define inline __inline__ +# endif +# ifndef unused +# define unused __unused__ +# endif +# ifndef volatile +# define volatile __volatile__ +# endif +#endif +#ifndef attribute +# define attribute(attr) __attribute__(attr) +#endif + +/* + * The structure used for communication between the processes + */ + +typedef struct _handle { + size_t len; + int errcode; + struct stat argument; + stat_t function; +} attribute((packed)) handle_t; + +static volatile handle_t handle; + +/* + * Using a forked process for doing e.g. stat(2) system call as this + * allows us to send e.g. SIGKILL to this process if it hangs in `D' + * state on a file share due a stalled NFS server. This does not work + * with (p)threads as SIGKILL would kill all threads including main. + */ + +static volatile pid_t active; +static int pipes[4] = {-1, -1, -1, -1}; + +static void attribute((constructor)) start(void) +{ + sigset_t sigset, oldset; + char path[PATH_MAX]; + handle_t handle; + ssize_t in; + + if (pipe(&pipes[0])) + goto error; + if (pipe(&pipes[2])) + goto error; + if ((active = fork()) < 0) + goto error; + if (active) { + close(pipes[0]); + close(pipes[3]); + pipes[0] = pipes[3] = -1; + return; + } + sigemptyset(&sigset); + sigaddset(&sigset, SIGALRM); + sigprocmask(SIG_BLOCK, &sigset, &oldset); + + close(pipes[1]); + close(pipes[2]); + dup2(pipes[0], 0); + dup2(pipes[3], 1); + close(pipes[0]); + close(pipes[3]); + pipes[1] = pipes[2] = -1; + pipes[0] = pipes[3] = -1; + + while ((in = read(0, &handle, sizeof(handle_t))) == sizeof(handle_t) && + (in = read(0, path, handle.len)) == handle.len) { + if (handle.function(path, &handle.argument) < 0) + handle.errcode = errno; + write(1, &handle.errcode, sizeof(handle.errcode)+sizeof(handle.argument)); + } + sigprocmask(SIG_SETMASK, &oldset, NULL); + exit(0); +error: + if (pipes[0] >= 0) close(pipes[0]); + if (pipes[1] >= 0) close(pipes[1]); + if (pipes[2] >= 0) close(pipes[2]); + if (pipes[3] >= 0) close(pipes[3]); +} + +static void /* attribute((destructor)) */ stop(void) +{ + if (active <= 0) + return; + if (waitpid(active, NULL, WNOHANG) == 0) + kill(active, SIGKILL); + active = 0; +} + +static sigjmp_buf jenv; +static void sigalarm(int sig attribute((unused))) +{ + siglongjmp(jenv, 1); +} + +/* + * External routine + */ + +int timeout(stat_t function, const char *path, struct stat *restrict argument, time_t seconds) +{ + struct sigaction old_act, new_act; + sigset_t sigset, oldset; + + if (active <= 0) { /* Oops, last one failed therefore clear status and restart */ + int status; + waitpid(-1, &status, WNOHANG); + start(); + } + + handle.len = strlen(path) + 1; + if (handle.len >= PATH_MAX) { + errno = ENAMETOOLONG; + goto error; + } + handle.errcode = 0; + handle.argument = *argument; + handle.function = function; + + sigemptyset(&sigset); + sigaddset(&sigset, SIGALRM); + sigprocmask(SIG_UNBLOCK, &sigset, &oldset); + + memset(&new_act, 0, sizeof(new_act)); + sigemptyset(&new_act.sa_mask); + new_act.sa_flags = SA_RESETHAND; + new_act.sa_handler = sigalarm; + + if (sigsetjmp(jenv, 1)) + goto timed; + + sigaction(SIGALRM, &new_act, &old_act); + alarm(seconds); + + write(pipes[1], &handle, sizeof(handle_t)); + write(pipes[1], path, handle.len); + sched_yield(); + read(pipes[2], &handle.errcode, sizeof(handle.errcode)+sizeof(handle.argument)); + + alarm(0); + sigaction(SIGALRM, &old_act, NULL); + + if (handle.errcode) { + errno = handle.errcode; + goto error; + } + + *argument = handle.argument; + sigprocmask(SIG_SETMASK, &oldset, NULL); + + return 0; +timed: + (void) alarm(0); + sigprocmask(SIG_SETMASK, &oldset, NULL); + stop(); + errno = ETIMEDOUT; +error: + return -1; +} + +/* + * End of timeout.c + */ diff --git a/src/timeout.h b/src/timeout.h index e69de29..50dd135 100644 --- a/src/timeout.h +++ b/src/timeout.h @@ -0,0 +1,36 @@ +/* + * timout.h Advanced timeout handling for file system calls + * to avoid deadlocks on remote file shares. + * + * Version: 0.1 07-Sep-2011 Fink + * + * Copyright 2011 Werner Fink, 2011 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 _TIMEOUT_H +#define _TIMEOUT_H + +#include "config.h" /* For _FILE_OFFSET_BITS */ + +#include +#include +#include +#include + +#if !defined(__STDC_VERSION__) || (__STDC_VERSION__ < 199901L) +# ifndef restrict +# define restrict __restrict__ +# endif +#endif + +typedef int (*stat_t)(const char *, struct stat *restrict); +extern int timeout(stat_t, const char *, struct stat *restrict, time_t); + +#endif