Emacs Hangs on Filesystem Operations on Stale NFS

[Alexander Shukaev]

Hi Everyone,


I initiated a discussion back in 2015 [1] about fragility of Emacs in 
terms of filesystem operations on stale NFS.  No solution actually came 
out of this discussion.  I still find this issue very disruptive.  Yet 
another example would be `recentf-cleanup' which is in my case triggered 
on Emacs start up, when the file comes from stale NFS, the corresponding 
`file-readable-p' down the stack will hang indefinitely, and there would 
be no way to unfreeze it apart from issuing 'kill -9' to that Emacs 
instance.  Don't you people find it unacceptable for the daily usage?  
Well, I do.  Such hangs always disrupt daily work and require quite some 
time to track them down as they are not Lisp-debuggable with e.g. <C-g> 
in a straightforward way (these are dead hangs from C code, where even 
attaching a GDB does not work).

Well, enough rant.  I think I have a proposal how to fix the issue, even 
given the blocking nature of Emacs.  How about introducing a variable 
`file-access-timeout' defaulting to `nil', which would reflect a 
configurable timeout for all access operations (such as 
`file-readable-p')?  This would be achieved via `SIGALARM' in the C 
code, which would protect every such operation.  For example,

#include <sigaction.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>

static void alarm_handler(int sig)
{
    return;
}

int emacs_stat(const char* path, struct stat* s, unsigned int seconds)
{
    struct sigaction newact;
    struct sigaction oldact;

    memset(&newact, 0, sizeof(newact));
    memset(&oldact, 0, sizeof(oldact));

    sigemptyset(&newact.sa_mask);

    newact.sa_flags   = 0;
    newact.sa_handler = alarm_handler;
    sigaction(SIGALRM, &newact, &oldact);

    alarm(seconds);

    errno                 = 0;
    const int rc          = stat(path, s);
    const int saved_errno = errno;

    alarm(0);
    sigaction(SIGALRM, &oldact, NULL);

    errno = saved_errno;
    return rc;
}

where `seconds' should be initialized with the value of 
`file-access-timeout'.  The cool advantage of this that I see is that 
one can then also selectively `let'-bind different values for 
`file-access-timeout', thus having total control over the use cases in 
which one wants to protect oneself from indefinite hangs.

Kind regards,
Alexander

[1] 
https://lists.gnu.org/archive/html/help-gnu-emacs/2015-11/msg00251.html