From fd6fc97156c6dfcd1e88d4c0e404d320dca06921 Mon Sep 17 00:00:00 2001 From: Jim Meyering Date: Sat, 10 Mar 2007 11:39:50 +0100 Subject: Try to fix today's NFS-related failure: Treat ESTALE like EACCES. * gl/lib/savewd.c: Copy this file from gnulib, then change "errno != EACCES" to (errno != EACCES && errno != ESTALE). The symptom was this failure in tests/install/basic-1: ginstall: cannot create directory `rel/a': Stale NFS file handle --- ChangeLog | 6 ++ gl/lib/savewd.c | 308 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 314 insertions(+) create mode 100644 gl/lib/savewd.c diff --git a/ChangeLog b/ChangeLog index 0d35e77e2..ad29325a8 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,5 +1,11 @@ 2007-03-10 Jim Meyering + Try to fix today's NFS-related failure: Treat ESTALE like EACCES. + * gl/lib/savewd.c: Copy this file from gnulib, then change + "errno != EACCES" to (errno != EACCES && errno != ESTALE). + The symptom was this failure in tests/install/basic-1: + ginstall: cannot create directory `rel/a': Stale NFS file handle + The preceding change solved part of the problem. Now ginstall fails. * tests/install/basic-1: Temporarily, don't redirect ginstall's stderr to /dev/null, so I can see why the NFS autobuilder's NFS test diff --git a/gl/lib/savewd.c b/gl/lib/savewd.c new file mode 100644 index 000000000..a6ee23517 --- /dev/null +++ b/gl/lib/savewd.c @@ -0,0 +1,308 @@ +/* Save and restore the working directory, possibly using a child process. + + Copyright (C) 2006, 2007 Free Software Foundation, Inc. + + 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, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ + +/* Written by Paul Eggert. */ + +#include + +#include "savewd.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "dirname.h" +#include "fcntl-safer.h" + + +/* Save the working directory into *WD, if it hasn't been saved + already. Return true if a child has been forked to do the real + work. */ +static bool +savewd_save (struct savewd *wd) +{ + switch (wd->state) + { + case INITIAL_STATE: + /* Save the working directory, or prepare to fall back if possible. */ + { + int fd = open_safer (".", O_RDONLY); + if (0 <= fd) + { + wd->state = FD_STATE; + wd->val.fd = fd; + break; + } + if (errno != EACCES && errno != ESTALE) + { + wd->state = ERROR_STATE; + wd->val.errnum = errno; + break; + } + } + wd->state = FORKING_STATE; + wd->val.child = -1; + /* Fall through. */ + case FORKING_STATE: + if (wd->val.child < 0) + { + /* "Save" the initial working directory by forking a new + subprocess that will attempt all the work from the chdir + until until the next savewd_restore. */ + wd->val.child = fork (); + if (wd->val.child != 0) + { + if (0 < wd->val.child) + return true; + wd->state = ERROR_STATE; + wd->val.errnum = errno; + } + } + break; + + case FD_STATE: + case FD_POST_CHDIR_STATE: + case ERROR_STATE: + case FINAL_STATE: + break; + + default: + assert (false); + } + + return false; +} + +int +savewd_chdir (struct savewd *wd, char const *dir, int options, + int open_result[2]) +{ + int fd = -1; + int result = 0; + + /* Open the directory if requested, or if avoiding a race condition + is requested and possible. */ + if (open_result + || (options & (HAVE_WORKING_O_NOFOLLOW ? SAVEWD_CHDIR_NOFOLLOW : 0))) + { + fd = open (dir, + (O_RDONLY | O_DIRECTORY | O_NOCTTY | O_NONBLOCK + | (options & SAVEWD_CHDIR_NOFOLLOW ? O_NOFOLLOW : 0))); + + if (open_result) + { + open_result[0] = fd; + open_result[1] = errno; + } + + if (fd < 0 && ((errno != EACCES && errno != ESTALE) + || (options & SAVEWD_CHDIR_READABLE))) + result = -1; + } + + if (result == 0 && ! (0 <= fd && options & SAVEWD_CHDIR_SKIP_READABLE)) + { + if (savewd_save (wd)) + { + open_result = NULL; + result = -2; + } + else + { + result = (fd < 0 ? chdir (dir) : fchdir (fd)); + + if (result == 0) + switch (wd->state) + { + case FD_STATE: + wd->state = FD_POST_CHDIR_STATE; + break; + + case ERROR_STATE: + case FD_POST_CHDIR_STATE: + case FINAL_STATE: + break; + + case FORKING_STATE: + assert (wd->val.child == 0); + break; + + default: + assert (false); + } + } + } + + if (0 <= fd && ! open_result) + { + int e = errno; + close (fd); + errno = e; + } + + return result; +} + +int +savewd_restore (struct savewd *wd, int status) +{ + switch (wd->state) + { + case INITIAL_STATE: + case FD_STATE: + /* The working directory is the desired directory, so there's no + work to do. */ + break; + + case FD_POST_CHDIR_STATE: + /* Restore the working directory using fchdir. */ + if (fchdir (wd->val.fd) == 0) + { + wd->state = FD_STATE; + break; + } + else + { + int chdir_errno = errno; + close (wd->val.fd); + wd->state = ERROR_STATE; + wd->val.errnum = chdir_errno; + } + /* Fall through. */ + case ERROR_STATE: + /* Report an error if asked to restore the working directory. */ + errno = wd->val.errnum; + return -1; + + case FORKING_STATE: + /* "Restore" the working directory by waiting for the subprocess + to finish. */ + { + pid_t child = wd->val.child; + if (child == 0) + _exit (status); + if (0 < child) + { + int child_status; + while (waitpid (child, &child_status, 0) < 0) + assert (errno == EINTR); + wd->val.child = -1; + if (! WIFEXITED (child_status)) + raise (WTERMSIG (child_status)); + return WEXITSTATUS (child_status); + } + } + break; + + default: + assert (false); + } + + return 0; +} + +void +savewd_finish (struct savewd *wd) +{ + switch (wd->state) + { + case INITIAL_STATE: + case ERROR_STATE: + break; + + case FD_STATE: + case FD_POST_CHDIR_STATE: + close (wd->val.fd); + break; + + case FORKING_STATE: + assert (wd->val.child < 0); + break; + + default: + assert (false); + } + + wd->state = FINAL_STATE; +} + +/* Return true if the actual work is currently being done by a + subprocess. + + A true return means that the caller and the subprocess should + resynchronize later with savewd_restore, using only their own + memory to decide when to resynchronize; they should not consult the + file system to decide, because that might lead to race conditions. + This is why savewd_chdir is broken out into another function; + savewd_chdir's callers _can_ inspect the file system to decide + whether to call savewd_chdir. */ +static inline bool +savewd_delegating (struct savewd const *wd) +{ + return wd->state == FORKING_STATE && 0 < wd->val.child; +} + +int +savewd_process_files (int n_files, char **file, + int (*act) (char *, struct savewd *, void *), + void *options) +{ + int i = 0; + int last_relative; + int exit_status = EXIT_SUCCESS; + struct savewd wd; + savewd_init (&wd); + + for (last_relative = n_files - 1; 0 <= last_relative; last_relative--) + if (! IS_ABSOLUTE_FILE_NAME (file[last_relative])) + break; + + for (; i < last_relative; i++) + { + if (! savewd_delegating (&wd)) + { + int s = act (file[i], &wd, options); + if (exit_status < s) + exit_status = s; + } + + if (! IS_ABSOLUTE_FILE_NAME (file[i + 1])) + { + int r = savewd_restore (&wd, exit_status); + if (exit_status < r) + exit_status = r; + } + } + + savewd_finish (&wd); + + for (; i < n_files; i++) + { + int s = act (file[i], &wd, options); + if (exit_status < s) + exit_status = s; + } + + return exit_status; +} -- cgit v1.2.3-54-g00ecf